1 /*
2 * The JUnit-addons Software License, Version 1.0
3 * (based on the Apache Software License, Version 1.1)
4 *
5 * Copyright (c) 2002-2003 Vladimir R. Bossicard. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * 3. The end-user documentation included with the redistribution, if
20 * any, must include the following acknowlegement:
21 * "This product includes software developed by Vladimir R.
22 * Bossicard as well as other contributors
23 * (http://junit-addons.sourceforge.net/)."
24 * Alternately, this acknowlegement may appear in the software itself,
25 * if and wherever such third-party acknowlegements normally appear.
26 *
27 * 4. The name "JUnit-addons" must not be used to endorse or promote
28 * products derived from this software without prior written
29 * permission. For written permission, please contact
30 * vbossica@users.sourceforge.net.
31 *
32 * 5. Products derived from this software may not be called "JUnit-addons"
33 * nor may "JUnit-addons" appear in their names without prior written
34 * permission of the project managers.
35 *
36 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47 * SUCH DAMAGE.
48 * ======================================================================
49 *
50 * This software consists of voluntary contributions made by many
51 * individuals. For more information on the JUnit-addons Project, please
52 * see <http://junit-addons.sourceforge.net/>.
53 */
54
55 package junitx.framework;
56
57 /**
58 * A set of assert methods (primarly testing the negative assertion of the
59 * correspondent methods found in the <tt>junit.framework.Assert</tt> class).
60 *
61 * <h4>Usage</h4>
62 *
63 * <pre>
64 * import junitx.framework.Assert;
65 *
66 * Assert.assertNotEquals(expected, actual);
67 * </pre>
68 *
69 * @version $Revision: 1.13 $ $Date: 2003/03/21 06:13:49 $
70 * @author <a href="mailto:vbossica@users.sourceforge.net">Vladimir R. Bossicard</a>
71 */
72 public class Assert
73 extends junit.framework.Assert {
74
75 /**
76 * Don't let anyone have access to this constructor.
77 */
78 private Assert() {
79 }
80
81 /**
82 * Asserts that a condition is false. Throws a
83 * <tt>junitx.framework.ComparisonFailure</tt> if not.
84 *
85 * @see junitx.framework.ComparisonFailure
86 */
87 public static void assertFalse(String message,
88 boolean condition) {
89 if (condition) {
90 failFalse(message);
91 }
92 }
93
94 /**
95 * Asserts that a condition is false. Throws a
96 * <tt>junitx.framework.ComparisonFailure</tt> if not.
97 *
98 * @see junitx.framework.ComparisonFailure
99 */
100 public static void assertFalse(boolean condition) {
101 assertFalse(null, condition);
102 }
103
104 /**
105 * Asserts that two strings are equal. Throws an
106 * <tt>AssertionFailedError</tt> if not.
107 */
108 public static void assertEquals(String expected, String actual) {
109 assertEquals(null, expected, actual);
110 }
111
112 /**
113 * Asserts that two strings are equal. Throws an
114 * <tt>AssertionFailedError</tt> if not.
115 */
116 public static void assertEquals(String message, String expected, String actual) {
117 if ((expected == null && actual == null) || (expected != null && expected.equals(actual))) {
118 return;
119 }
120 throw new ComparisonFailure(message, expected, actual);
121 }
122
123 /**
124 * Asserts that two objects are not equal. Throws an
125 * <tt>AssertionFailedError</tt> if they are equal.
126 */
127 public static void assertNotEquals(String message,
128 Object expected,
129 Object actual) {
130 if ((expected == null && actual == null) ||
131 (expected != null && expected.equals(actual))) {
132 failNotEquals(message, expected);
133 }
134 }
135
136 /**
137 * Asserts that two objects are not equal. Throws an
138 * <tt>AssertionFailedError</tt> if they are equal.
139 */
140 public static void assertNotEquals(Object expected,
141 Object actual) {
142 assertNotEquals(null, expected, actual);
143 }
144
145 /**
146 * Asserts that two bytes are not equal. Throws an
147 * <tt>AssertionFailedError</tt> if they are equal.
148 */
149 public static void assertNotEquals(String message,
150 byte expected,
151 byte actual) {
152 assertNotEquals(message, new Byte(expected), new Byte(actual));
153 }
154
155 /**
156 * Asserts that two bytes are not equal. Throws an
157 * <tt>AssertionFailedError</tt> if they are equal.
158 */
159 public static void assertNotEquals(byte expected,
160 byte actual) {
161 assertNotEquals(null, expected, actual);
162 }
163
164 /**
165 * Asserts that two chars are not equal. Throws an
166 * <tt>AssertionFailedError</tt> if they are equal.
167 */
168 public static void assertNotEquals(String message,
169 char expected,
170 char actual) {
171 assertNotEquals(message, new Character(expected), new Character(actual));
172 }
173
174 /**
175 * Asserts that two chars are not equal. Throws an
176 * <tt>AssertionFailedError</tt> if they are equal.
177 */
178 public static void assertNotEquals(char expected,
179 char actual) {
180 assertNotEquals(null, expected, actual);
181 }
182
183 /**
184 * Asserts that two doubles are not equal concerning a delta. If the
185 * expected value is infinity then the delta value is ignored. Throws an
186 * <tt>AssertionFailedError</tt> if they are equal.
187 */
188 public static void assertNotEquals(String message,
189 double expected,
190 double actual,
191 double delta) {
192 if (Double.isInfinite(expected)) {
193 if (expected == actual) {
194 failNotEquals(message, new Double(expected));
195 }
196 } else if (Math.abs(expected - actual) <= delta) {
197 failNotEquals(message, new Double(expected));
198 }
199 }
200
201 /**
202 * Asserts that two doubles are not equal concerning a delta. If the
203 * expected value is infinity then the delta value is ignored. Throws an
204 * <tt>AssertionFailedError</tt> if they are equal.
205 */
206 public static void assertNotEquals(double expected,
207 double actual,
208 double delta) {
209 assertNotEquals(null, expected, actual, delta);
210 }
211
212 /**
213 * Asserts that two floats are not equal concerning a delta. If the
214 * expected value is infinity then the delta value is ignored. Throws an
215 * <tt>AssertionFailedError</tt> if they are equal.
216 */
217 public static void assertNotEquals(String message,
218 float expected,
219 float actual,
220 float delta) {
221 if (Float.isInfinite(expected)) {
222 if (expected == actual) {
223 failNotEquals(message, new Float(expected));
224 }
225 } else if (Math.abs(expected - actual) <= delta) {
226 failNotEquals(message, new Float(expected));
227 }
228 }
229
230 /**
231 * Asserts that two floats are not equal concerning a delta. If the
232 * expected value is infinity then the delta value is ignored. Throws an
233 * <tt>AssertionFailedError</tt> if they are equal.
234 */
235 public static void assertNotEquals(float expected,
236 float actual,
237 float delta) {
238 assertNotEquals(null, expected, actual, delta);
239 }
240
241 /**
242 * Asserts that two ints are not equal. Throws an
243 * <tt>AssertionFailedError</tt> if they are equal.
244 */
245 public static void assertNotEquals(String message,
246 int expected,
247 int actual) {
248 assertNotEquals(message, new Integer(expected), new Integer(actual));
249 }
250
251 /**
252 * Asserts that two ints are not equal. Throws an
253 * <tt>AssertionFailedError</tt> if they are equal.
254 */
255 public static void assertNotEquals(int expected,
256 int actual) {
257 assertNotEquals(null, expected, actual);
258 }
259
260 /**
261 * Asserts that longs objects are not equal. Throws an
262 * <tt>AssertionFailedError</tt> if they are equal.
263 */
264 public static void assertNotEquals(String message,
265 long expected,
266 long actual) {
267 assertNotEquals(message, new Long(expected), new Long(actual));
268 }
269
270 /**
271 * Asserts that two longs are not equal. Throws an
272 * <tt>AssertionFailedError</tt> if they are equal.
273 */
274 public static void assertNotEquals(long expected,
275 long actual) {
276 assertNotEquals(null, expected, actual);
277 }
278
279 /**
280 * Asserts that two shorts are not equal. Throws an
281 * <tt>AssertionFailedError</tt> if they are equal.
282 */
283 public static void assertNotEquals(String message,
284 short expected,
285 short actual) {
286 assertNotEquals(message, new Short(expected), new Short(actual));
287 }
288
289 /**
290 * Asserts that two shorts are not equal. Throws an
291 * <tt>AssertionFailedError</tt> if they are equal.
292 */
293 public static void assertNotEquals(short expected,
294 short actual) {
295 assertNotEquals(null, expected, actual);
296 }
297
298 /**
299 * Asserts that two boolean are not equal. Throws an
300 * <tt>AssertionFailedError</tt> if they are equal.
301 */
302 public static void assertNotEquals(String message,
303 boolean expected,
304 boolean actual) {
305 assertNotEquals(message, new Boolean(expected), new Boolean(actual));
306 }
307
308 /**
309 * Asserts that two booleans are not equal. Throws an
310 * <tt>AssertionFailedError</tt> if they are equal.
311 */
312 public static void assertNotEquals(boolean expected,
313 boolean actual) {
314 assertNotEquals(null, expected, actual);
315 }
316
317 /**
318 * Asserts that two objects do not refer to the same object. Throws an
319 * <tt>AssertionFailedError</tt> if they are equal.
320 */
321 public static void assertNotSame(String message,
322 Object expected,
323 Object actual) {
324 if (expected == actual) {
325 failSame(message, expected);
326 }
327 }
328
329 /**
330 * Asserts that two objects do not refer to the same object. Throws an
331 * <tt>AssertionFailedError</tt> if they are equal.
332 */
333 public static void assertNotSame(Object expected,
334 Object actual) {
335 assertNotSame(null, expected, actual);
336 }
337
338 static private void failFalse(String message) {
339 String formatted = "";
340 if (message != null) {
341 formatted = message + " ";
342 }
343
344 fail(formatted + "expected <false>");
345 }
346
347 static private void failNotEquals(String message,
348 Object expected) {
349 String formatted = "";
350 if (message != null) {
351 formatted = message + " ";
352 }
353
354 fail(formatted + "expected not equals to: <" + expected + ">");
355 }
356
357 static private void failSame(String message,
358 Object expected) {
359 String formatted = "";
360 if (message != null) {
361 formatted = message + " ";
362 }
363
364 fail(formatted + "expected not same as: <" + expected + ">");
365 }
366
367 /**
368 * Fails a test with the given <tt>Throwable</tt> object causing the
369 * failure.
370 */
371 static public void fail(Throwable cause) {
372 fail(null, cause);
373 }
374
375 /**
376 * Fails a test with the given message and the <tt>Throwable</tt> object
377 * causing the failure.
378 */
379 static public void fail(String message, Throwable cause) {
380 throw new AssertionFailedError(message, cause);
381 }
382
383 }