001: package org.testng;
002:
003: import java.util.Arrays;
004: import java.util.Collection;
005: import java.util.HashSet;
006: import java.util.Iterator;
007:
008: /**
009: * Assertion tool class. Presents assertion methods with a more natural parameter order.
010: * The order is always <B>actualValue</B>, <B>expectedValue</B> [, message].
011: *
012: * @author <a href='mailto:the_mindstorm@evolva.ro'>Alexandru Popescu</a>
013: */
014: public class Assert {
015:
016: /**
017: * Protect constructor since it is a static only class
018: */
019: protected Assert() {
020: // hide constructor
021: }
022:
023: /**
024: * Asserts that a condition is true. If it isn't,
025: * an AssertionError, with the given message, is thrown.
026: * @param condition the condition to evaluate
027: * @param message the assertion error message
028: */
029: static public void assertTrue(boolean condition, String message) {
030: if (!condition) {
031: failNotEquals(Boolean.valueOf(condition), Boolean.TRUE,
032: message);
033: }
034: }
035:
036: /**
037: * Asserts that a condition is true. If it isn't,
038: * an AssertionError is thrown.
039: * @param condition the condition to evaluate
040: */
041: static public void assertTrue(boolean condition) {
042: assertTrue(condition, null);
043: }
044:
045: /**
046: * Asserts that a condition is false. If it isn't,
047: * an AssertionError, with the given message, is thrown.
048: * @param condition the condition to evaluate
049: * @param message the assertion error message
050: */
051: static public void assertFalse(boolean condition, String message) {
052: if (condition) {
053: failNotEquals(Boolean.valueOf(condition), Boolean.FALSE,
054: message); // TESTNG-81
055: }
056: }
057:
058: /**
059: * Asserts that a condition is false. If it isn't,
060: * an AssertionError is thrown.
061: * @param condition the condition to evaluate
062: */
063: static public void assertFalse(boolean condition) {
064: assertFalse(condition, null);
065: }
066:
067: /**
068: * Fails a test with the given message and wrapping the original exception.
069: *
070: * @param message the assertion error message
071: * @param realCause the original exception
072: */
073: static public void fail(String message, Throwable realCause) {
074: AssertionError ae = new AssertionError(message);
075: ae.initCause(realCause);
076:
077: throw ae;
078: }
079:
080: /**
081: * Fails a test with the given message.
082: * @param message the assertion error message
083: */
084: static public void fail(String message) {
085: throw new AssertionError(message);
086: }
087:
088: /**
089: * Fails a test with no message.
090: */
091: static public void fail() {
092: fail(null);
093: }
094:
095: /**
096: * Asserts that two objects are equal. If they are not,
097: * an AssertionError, with the given message, is thrown.
098: * @param actual the actual value
099: * @param expected the expected value
100: * @param message the assertion error message
101: */
102: static public void assertEquals(Object actual, Object expected,
103: String message) {
104: if ((expected == null) && (actual == null)) {
105: return;
106: }
107: if ((expected != null) && expected.equals(actual)) {
108: return;
109: }
110: failNotEquals(actual, expected, message);
111: }
112:
113: /**
114: * Asserts that two objects are equal. If they are not,
115: * an AssertionError is thrown.
116: * @param actual the actual value
117: * @param expected the expected value
118: */
119: static public void assertEquals(Object actual, Object expected) {
120: assertEquals(actual, expected, null);
121: }
122:
123: /**
124: * Asserts that two Strings are equal. If they are not,
125: * an AssertionError, with the given message, is thrown.
126: * @param actual the actual value
127: * @param expected the expected value
128: * @param message the assertion error message
129: */
130: static public void assertEquals(String actual, String expected,
131: String message) {
132: assertEquals((Object) actual, (Object) expected, message);
133: }
134:
135: /**
136: * Asserts that two Strings are equal. If they are not,
137: * an AssertionError is thrown.
138: * @param actual the actual value
139: * @param expected the expected value
140: */
141: static public void assertEquals(String actual, String expected) {
142: assertEquals(actual, expected, null);
143: }
144:
145: /**
146: * Asserts that two doubles are equal concerning a delta. If they are not,
147: * an AssertionError, with the given message, is thrown. If the expected
148: * value is infinity then the delta value is ignored.
149: * @param actual the actual value
150: * @param expected the expected value
151: * @param delta the absolute tolerate value value between the actual and expected value
152: * @param message the assertion error message
153: */
154: static public void assertEquals(double actual, double expected,
155: double delta, String message) {
156: // handle infinity specially since subtracting to infinite values gives NaN and the
157: // the following test fails
158: if (Double.isInfinite(expected)) {
159: if (!(expected == actual)) {
160: failNotEquals(new Double(actual), new Double(expected),
161: message);
162: }
163: } else if (!(Math.abs(expected - actual) <= delta)) { // Because comparison with NaN always returns false
164: failNotEquals(new Double(actual), new Double(expected),
165: message);
166: }
167: }
168:
169: /**
170: * Asserts that two doubles are equal concerning a delta. If they are not,
171: * an AssertionError is thrown. If the expected value is infinity then the
172: * delta value is ignored.
173: * @param actual the actual value
174: * @param expected the expected value
175: * @param delta the absolute tolerate value value between the actual and expected value
176: */
177: static public void assertEquals(double actual, double expected,
178: double delta) {
179: assertEquals(actual, expected, delta, null);
180: }
181:
182: /**
183: * Asserts that two floats are equal concerning a delta. If they are not,
184: * an AssertionError, with the given message, is thrown. If the expected
185: * value is infinity then the delta value is ignored.
186: * @param actual the actual value
187: * @param expected the expected value
188: * @param delta the absolute tolerate value value between the actual and expected value
189: * @param message the assertion error message
190: */
191: static public void assertEquals(float actual, float expected,
192: float delta, String message) {
193: // handle infinity specially since subtracting to infinite values gives NaN and the
194: // the following test fails
195: if (Float.isInfinite(expected)) {
196: if (!(expected == actual)) {
197: failNotEquals(new Float(actual), new Float(expected),
198: message);
199: }
200: } else if (!(Math.abs(expected - actual) <= delta)) {
201: failNotEquals(new Float(actual), new Float(expected),
202: message);
203: }
204: }
205:
206: /**
207: * Asserts that two floats are equal concerning a delta. If they are not,
208: * an AssertionError is thrown. If the expected
209: * value is infinity then the delta value is ignored.
210: * @param actual the actual value
211: * @param expected the expected value
212: * @param delta the absolute tolerate value value between the actual and expected value
213: */
214: static public void assertEquals(float actual, float expected,
215: float delta) {
216: assertEquals(actual, expected, delta, null);
217: }
218:
219: /**
220: * Asserts that two longs are equal. If they are not,
221: * an AssertionError, with the given message, is thrown.
222: * @param actual the actual value
223: * @param expected the expected value
224: * @param message the assertion error message
225: */
226: static public void assertEquals(long actual, long expected,
227: String message) {
228: assertEquals(new Long(actual), new Long(expected), message);
229: }
230:
231: /**
232: * Asserts that two longs are equal. If they are not,
233: * an AssertionError is thrown.
234: * @param actual the actual value
235: * @param expected the expected value
236: */
237: static public void assertEquals(long actual, long expected) {
238: assertEquals(actual, expected, null);
239: }
240:
241: /**
242: * Asserts that two booleans are equal. If they are not,
243: * an AssertionError, with the given message, is thrown.
244: * @param actual the actual value
245: * @param expected the expected value
246: * @param message the assertion error message
247: */
248: static public void assertEquals(boolean actual, boolean expected,
249: String message) {
250: assertEquals(Boolean.valueOf(actual),
251: Boolean.valueOf(expected), message);
252: }
253:
254: /**
255: * Asserts that two booleans are equal. If they are not,
256: * an AssertionError is thrown.
257: * @param actual the actual value
258: * @param expected the expected value
259: */
260: static public void assertEquals(boolean actual, boolean expected) {
261: assertEquals(actual, expected, null);
262: }
263:
264: /**
265: * Asserts that two bytes are equal. If they are not,
266: * an AssertionError, with the given message, is thrown.
267: * @param actual the actual value
268: * @param expected the expected value
269: * @param message the assertion error message
270: */
271: static public void assertEquals(byte actual, byte expected,
272: String message) {
273: assertEquals(new Byte(actual), new Byte(expected), message);
274: }
275:
276: /**
277: * Asserts that two bytes are equal. If they are not,
278: * an AssertionError is thrown.
279: * @param actual the actual value
280: * @param expected the expected value
281: */
282: static public void assertEquals(byte actual, byte expected) {
283: assertEquals(actual, expected, null);
284: }
285:
286: /**
287: * Asserts that two chars are equal. If they are not,
288: * an AssertionFailedError, with the given message, is thrown.
289: * @param actual the actual value
290: * @param expected the expected value
291: * @param message the assertion error message
292: */
293: static public void assertEquals(char actual, char expected,
294: String message) {
295: assertEquals(new Character(actual), new Character(expected),
296: message);
297: }
298:
299: /**
300: * Asserts that two chars are equal. If they are not,
301: * an AssertionError is thrown.
302: * @param actual the actual value
303: * @param expected the expected value
304: */
305: static public void assertEquals(char actual, char expected) {
306: assertEquals(actual, expected, null);
307: }
308:
309: /**
310: * Asserts that two shorts are equal. If they are not,
311: * an AssertionFailedError, with the given message, is thrown.
312: * @param actual the actual value
313: * @param expected the expected value
314: * @param message the assertion error message
315: */
316: static public void assertEquals(short actual, short expected,
317: String message) {
318: assertEquals(new Short(actual), new Short(expected), message);
319: }
320:
321: /**
322: * Asserts that two shorts are equal. If they are not,
323: * an AssertionError is thrown.
324: * @param actual the actual value
325: * @param expected the expected value
326: */
327: static public void assertEquals(short actual, short expected) {
328: assertEquals(actual, expected, null);
329: }
330:
331: /**
332: * Asserts that two ints are equal. If they are not,
333: * an AssertionFailedError, with the given message, is thrown.
334: * @param actual the actual value
335: * @param expected the expected value
336: * @param message the assertion error message
337: */
338: static public void assertEquals(int actual, int expected,
339: String message) {
340: assertEquals(new Integer(actual), new Integer(expected),
341: message);
342: }
343:
344: /**
345: * Asserts that two ints are equal. If they are not,
346: * an AssertionError is thrown.
347: * @param actual the actual value
348: * @param expected the expected value
349: */
350: static public void assertEquals(int actual, int expected) {
351: assertEquals(actual, expected, null);
352: }
353:
354: /**
355: * Asserts that an object isn't null. If it is,
356: * an AssertionError is thrown.
357: * @param object the assertion object
358: */
359: static public void assertNotNull(Object object) {
360: assertNotNull(object, null);
361: }
362:
363: /**
364: * Asserts that an object isn't null. If it is,
365: * an AssertionFailedError, with the given message, is thrown.
366: * @param object the assertion object
367: * @param message the assertion error message
368: */
369: static public void assertNotNull(Object object, String message) {
370: assertTrue(object != null, message);
371: }
372:
373: /**
374: * Asserts that an object is null. If it is,
375: * an AssertionError, with the given message, is thrown.
376: * @param object the assertion object
377: */
378: static public void assertNull(Object object) {
379: assertNull(object, null);
380: }
381:
382: /**
383: * Asserts that an object is null. If it is not,
384: * an AssertionFailedError, with the given message, is thrown.
385: * @param object the assertion object
386: * @param message the assertion error message
387: */
388: static public void assertNull(Object object, String message) {
389: assertTrue(object == null, message);
390: }
391:
392: /**
393: * Asserts that two objects refer to the same object. If they do not,
394: * an AssertionFailedError, with the given message, is thrown.
395: * @param actual the actual value
396: * @param expected the expected value
397: * @param message the assertion error message
398: */
399: static public void assertSame(Object actual, Object expected,
400: String message) {
401: if (expected == actual) {
402: return;
403: }
404: failNotSame(actual, expected, message);
405: }
406:
407: /**
408: * Asserts that two objects refer to the same object. If they do not,
409: * an AssertionError is thrown.
410: * @param actual the actual value
411: * @param expected the expected value
412: */
413: static public void assertSame(Object actual, Object expected) {
414: assertSame(actual, expected, null);
415: }
416:
417: /**
418: * Asserts that two objects do not refer to the same objects. If they do,
419: * an AssertionError, with the given message, is thrown.
420: * @param actual the actual value
421: * @param expected the expected value
422: * @param message the assertion error message
423: */
424: static public void assertNotSame(Object actual, Object expected,
425: String message) {
426: if (expected == actual) {
427: failSame(actual, expected, message);
428: }
429: }
430:
431: /**
432: * Asserts that two objects do not refer to the same object. If they do,
433: * an AssertionError is thrown.
434: * @param actual the actual value
435: * @param expected the expected value
436: */
437: static public void assertNotSame(Object actual, Object expected) {
438: assertNotSame(actual, expected, null);
439: }
440:
441: static private void failSame(Object actual, Object expected,
442: String message) {
443: String formatted = "";
444: if (message != null) {
445: formatted = message + " ";
446: }
447: fail(formatted + "expected not same with:<" + expected
448: + "> but was same:<" + actual + ">");
449: }
450:
451: static private void failNotSame(Object actual, Object expected,
452: String message) {
453: String formatted = "";
454: if (message != null) {
455: formatted = message + " ";
456: }
457: fail(formatted + "expected same with:<" + expected
458: + "> but was:<" + actual + ">");
459: }
460:
461: static private void failNotEquals(Object actual, Object expected,
462: String message) {
463: fail(format(actual, expected, message));
464: }
465:
466: static String format(Object actual, Object expected, String message) {
467: String formatted = "";
468: if (null != message) {
469: formatted = message + " ";
470: }
471:
472: return formatted + "expected:<" + expected + "> but was:<"
473: + actual + ">";
474: }
475:
476: /**
477: * Asserts that two collections contain the same elements in the same order. If they do not,
478: * an AssertionError is thrown.
479: *
480: * @param actual the actual value
481: * @param expected the expected value
482: */
483: static public void assertEquals(Collection actual,
484: Collection expected) {
485: assertEquals(actual, expected, null);
486: }
487:
488: /**
489: * Asserts that two collections contain the same elements in the same order. If they do not,
490: * an AssertionError, with the given message, is thrown.
491: * @param actual the actual value
492: * @param expected the expected value
493: * @param message the assertion error message
494: */
495: static public void assertEquals(Collection actual,
496: Collection expected, String message) {
497: if (actual == expected)
498: return;
499:
500: if ((actual == null && expected != null)
501: || (actual != null && expected == null)) {
502: if (message != null)
503: fail(message);
504: else
505: fail("Arrays not equal: " + expected + " and " + actual);
506: }
507:
508: assertEquals(actual.size(), expected.size(), message
509: + ": lists don't have the same size");
510:
511: Iterator actIt = actual.iterator();
512: Iterator expIt = expected.iterator();
513: int i = -1;
514: while (actIt.hasNext() && expIt.hasNext()) {
515: i++;
516: Object e = expIt.next();
517: Object a = actIt.next();
518: String errorMessage = message == null ? "Lists differ at element ["
519: + i + "]: " + e + " != " + a
520: : message + ": Lists differ at element [" + i
521: + "]: " + e + " != " + a;
522:
523: assertEquals(a, e, errorMessage);
524: }
525: }
526:
527: /**
528: * Asserts that two arrays contain the same elements in the same order. If they do not,
529: * an AssertionError, with the given message, is thrown.
530: * @param actual the actual value
531: * @param expected the expected value
532: * @param message the assertion error message
533: */
534: static public void assertEquals(Object[] actual, Object[] expected,
535: String message) {
536: if (actual == expected)
537: return;
538:
539: if ((actual == null && expected != null)
540: || (actual != null && expected == null)) {
541: if (message != null)
542: fail(message);
543: else
544: fail("Arrays not equal: " + expected + " and " + actual);
545: }
546: assertEquals(Arrays.asList(actual), Arrays.asList(expected),
547: message);
548: }
549:
550: /**
551: * Asserts that two arrays contain the same elements in no particular order. If they do not,
552: * an AssertionError, with the given message, is thrown.
553: * @param actual the actual value
554: * @param expected the expected value
555: * @param message the assertion error message
556: */
557: static public void assertEqualsNoOrder(Object[] actual,
558: Object[] expected, String message) {
559: if (actual == expected)
560: return;
561:
562: if ((actual == null && expected != null)
563: || (actual != null && expected == null)) {
564: if (message != null)
565: fail(message);
566: else
567: fail("Arrays not equal: " + expected + " and " + actual);
568: }
569:
570: Collection actualCollection = new HashSet();
571: for (Object a : actual) {
572: actualCollection.add(a);
573: }
574:
575: Collection expectedCollection = new HashSet();
576: for (Object a : expected) {
577: expectedCollection.add(a);
578: }
579:
580: assertEquals(actualCollection, expectedCollection, message);
581: }
582:
583: /**
584: * Asserts that two arrays contain the same elements in the same order. If they do not,
585: * an AssertionError is thrown.
586: *
587: * @param actual the actual value
588: * @param expected the expected value
589: */
590: static public void assertEquals(Object[] actual, Object[] expected) {
591: assertEquals(actual, expected, null);
592: }
593:
594: /**
595: * Asserts that two arrays contain the same elements in no particular order. If they do not,
596: * an AssertionError is thrown.
597: * @param actual the actual value
598: * @param expected the expected value
599: */
600: static public void assertEqualsNoOrder(Object[] actual,
601: Object[] expected) {
602: assertEqualsNoOrder(actual, expected, null);
603: }
604:
605: /**
606: * Asserts that two arrays contain the same elements in the same order. If they do not,
607: * an AssertionError is thrown.
608: *
609: * @param actual the actual value
610: * @param expected the expected value
611: */
612: static public void assertEquals(final byte[] actual,
613: final byte[] expected) {
614: assertEquals(actual, expected, "");
615: }
616:
617: /**
618: * Asserts that two arrays contain the same elements in the same order. If they do not,
619: * an AssertionError, with the given message, is thrown.
620: *
621: * @param actual the actual value
622: * @param expected the expected value
623: * @param message the assertion error message
624: */
625: static public void assertEquals(final byte[] actual,
626: final byte[] expected, final String message) {
627: if (expected == actual) {
628: return;
629: }
630: if (null == expected) {
631: fail("expected a null array, but not null found. "
632: + message);
633: }
634: if (null == actual) {
635: fail("expected not null array, but null found. " + message);
636: }
637:
638: assertEquals(actual.length, expected.length,
639: "arrays don't have the same size. " + message);
640:
641: for (int i = 0; i < expected.length; i++) {
642: if (expected[i] != actual[i]) {
643: fail("arrays differ firstly at element [" + i + "]; "
644: + "expected value is <" + expected[i]
645: + "> but was <" + actual[i] + ">. " + message);
646: }
647: }
648: }
649: }
|