1 package org.junit.tests.assertion;
2
3 import static org.hamcrest.CoreMatchers.equalTo;
4 import static org.hamcrest.CoreMatchers.instanceOf;
5 import static org.hamcrest.CoreMatchers.is;
6 import static org.junit.Assert.assertArrayEquals;
7 import static org.junit.Assert.assertEquals;
8 import static org.junit.Assert.assertNotEquals;
9 import static org.junit.Assert.assertNotSame;
10 import static org.junit.Assert.assertNull;
11 import static org.junit.Assert.assertSame;
12 import static org.junit.Assert.assertThat;
13 import static org.junit.Assert.assertTrue;
14 import static org.junit.Assert.fail;
15
16 import java.math.BigDecimal;
17
18 import org.junit.Assert;
19 import org.junit.ComparisonFailure;
20 import org.junit.Test;
21 import org.junit.internal.ArrayComparisonFailure;
22
23
24
25
26 public class AssertionTest {
27
28
29
30
31
32
33
34 @Test(expected = AssertionError.class)
35 public void fails() {
36 Assert.fail();
37 }
38
39 @Test
40 public void failWithNoMessageToString() {
41 try {
42 Assert.fail();
43 } catch (AssertionError exception) {
44 assertEquals("java.lang.AssertionError", exception.toString());
45 }
46 }
47
48 @Test
49 public void failWithMessageToString() {
50 try {
51 Assert.fail("woops!");
52 } catch (AssertionError exception) {
53 assertEquals("java.lang.AssertionError: woops!", exception.toString());
54 }
55 }
56
57 @Test(expected = AssertionError.class)
58 public void arraysNotEqual() {
59 assertArrayEquals((new Object[]{new Object()}), (new Object[]{new Object()}));
60 }
61
62 @Test(expected = AssertionError.class)
63 public void arraysNotEqualWithMessage() {
64 assertArrayEquals("not equal", (new Object[]{new Object()}), (new Object[]{new Object()}));
65 }
66
67 @Test
68 public void arraysExpectedNullMessage() {
69 try {
70 assertArrayEquals("not equal", null, (new Object[]{new Object()}));
71 } catch (AssertionError exception) {
72 assertEquals("not equal: expected array was null", exception.getMessage());
73 }
74 }
75
76 @Test
77 public void arraysActualNullMessage() {
78 try {
79 assertArrayEquals("not equal", (new Object[]{new Object()}), null);
80 } catch (AssertionError exception) {
81 assertEquals("not equal: actual array was null", exception.getMessage());
82 }
83 }
84
85 @Test
86 public void arraysDifferentLengthMessage() {
87 try {
88 assertArrayEquals("not equal", (new Object[0]), (new Object[1]));
89 } catch (AssertionError exception) {
90 assertEquals("not equal: array lengths differed, expected.length=0 actual.length=1", exception.getMessage());
91 }
92 }
93
94 @Test(expected = ArrayComparisonFailure.class)
95 public void arraysElementsDiffer() {
96 assertArrayEquals("not equal", (new Object[]{"this is a very long string in the middle of an array"}), (new Object[]{"this is another very long string in the middle of an array"}));
97 }
98
99 @Test
100 public void arraysDifferAtElement0nullMessage() {
101 try {
102 assertArrayEquals((new Object[]{true}), (new Object[]{false}));
103 } catch (AssertionError exception) {
104 assertEquals("arrays first differed at element [0]; expected:<true> but was:<false>", exception
105 .getMessage());
106 }
107 }
108
109 @Test
110 public void arraysDifferAtElement1nullMessage() {
111 try {
112 assertArrayEquals((new Object[]{true, true}), (new Object[]{true,
113 false}));
114 } catch (AssertionError exception) {
115 assertEquals("arrays first differed at element [1]; expected:<true> but was:<false>", exception
116 .getMessage());
117 }
118 }
119
120 @Test
121 public void arraysDifferAtElement0withMessage() {
122 try {
123 assertArrayEquals("message", (new Object[]{true}), (new Object[]{false}));
124 } catch (AssertionError exception) {
125 assertEquals("message: arrays first differed at element [0]; expected:<true> but was:<false>", exception
126 .getMessage());
127 }
128 }
129
130 @Test
131 public void arraysDifferAtElement1withMessage() {
132 try {
133 assertArrayEquals("message", (new Object[]{true, true}), (new Object[]{true, false}));
134 fail();
135 } catch (AssertionError exception) {
136 assertEquals("message: arrays first differed at element [1]; expected:<true> but was:<false>", exception.getMessage());
137 }
138 }
139
140 @Test
141 public void multiDimensionalArraysAreEqual() {
142 assertArrayEquals((new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {false, false}}));
143 }
144
145 @Test
146 public void multiDimensionalIntArraysAreEqual() {
147 int[][] int1 = {{1, 2, 3}, {4, 5, 6}};
148 int[][] int2 = {{1, 2, 3}, {4, 5, 6}};
149 assertArrayEquals(int1, int2);
150 }
151
152 @Test
153 public void oneDimensionalPrimitiveArraysAreEqual() {
154 assertArrayEquals(new boolean[]{true}, new boolean[]{true});
155 assertArrayEquals(new byte[]{1}, new byte[]{1});
156 assertArrayEquals(new char[]{1}, new char[]{1});
157 assertArrayEquals(new short[]{1}, new short[]{1});
158 assertArrayEquals(new int[]{1}, new int[]{1});
159 assertArrayEquals(new long[]{1}, new long[]{1});
160 assertArrayEquals(new double[]{1.0}, new double[]{1.0}, 1.0);
161 assertArrayEquals(new float[]{1.0f}, new float[]{1.0f}, 1.0f);
162 }
163
164 @Test(expected = AssertionError.class)
165 public void oneDimensionalDoubleArraysAreNotEqual() {
166 assertArrayEquals(new double[]{1.0}, new double[]{2.5}, 1.0);
167 }
168
169 @Test(expected = AssertionError.class)
170 public void oneDimensionalFloatArraysAreNotEqual() {
171 assertArrayEquals(new float[]{1.0f}, new float[]{2.5f}, 1.0f);
172 }
173
174 @Test(expected = AssertionError.class)
175 public void oneDimensionalBooleanArraysAreNotEqual() {
176 assertArrayEquals(new boolean[]{true}, new boolean[]{false});
177 }
178
179 @Test(expected = AssertionError.class)
180 public void IntegerDoesNotEqualLong() {
181 assertEquals(new Integer(1), new Long(1));
182 }
183
184 @Test
185 public void intsEqualLongs() {
186 assertEquals(1, 1L);
187 }
188
189 @Test
190 public void multiDimensionalArraysDeclaredAsOneDimensionalAreEqual() {
191 assertArrayEquals((new Object[]{new Object[]{true, true}, new Object[]{false, false}}), (new Object[]{new Object[]{true, true}, new Object[]{false, false}}));
192 }
193
194 @Test
195 public void multiDimensionalArraysAreNotEqual() {
196 try {
197 assertArrayEquals("message", (new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {true, false}}));
198 fail();
199 } catch (AssertionError exception) {
200 assertEquals("message: arrays first differed at element [1][0]; expected:<false> but was:<true>", exception.getMessage());
201 }
202 }
203
204 @Test
205 public void multiDimensionalArraysAreNotEqualNoMessage() {
206 try {
207 assertArrayEquals((new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {true, false}}));
208 fail();
209 } catch (AssertionError exception) {
210 assertEquals("arrays first differed at element [1][0]; expected:<false> but was:<true>", exception.getMessage());
211 }
212 }
213
214 @Test
215 public void arraysWithNullElementEqual() {
216 Object[] objects1 = new Object[]{null};
217 Object[] objects2 = new Object[]{null};
218 assertArrayEquals(objects1, objects2);
219 }
220
221 @Test
222 public void stringsDifferWithUserMessage() {
223 try {
224 assertEquals("not equal", "one", "two");
225 } catch (Throwable exception) {
226 assertEquals("not equal expected:<[one]> but was:<[two]>", exception.getMessage());
227 }
228 }
229
230 @Test
231 public void arraysEqual() {
232 Object element = new Object();
233 Object[] objects1 = new Object[]{element};
234 Object[] objects2 = new Object[]{element};
235 assertArrayEquals(objects1, objects2);
236 }
237
238 @Test
239 public void arraysEqualWithMessage() {
240 Object element = new Object();
241 Object[] objects1 = new Object[]{element};
242 Object[] objects2 = new Object[]{element};
243 assertArrayEquals("equal", objects1, objects2);
244 }
245
246 @Test
247 public void equals() {
248 Object o = new Object();
249 assertEquals(o, o);
250 assertEquals("abc", "abc");
251 assertEquals(true, true);
252 assertEquals((byte) 1, (byte) 1);
253 assertEquals('a', 'a');
254 assertEquals((short) 1, (short) 1);
255 assertEquals(1, 1);
256 assertEquals(1l, 1l);
257 assertEquals(1.0, 1.0, 0.0);
258 assertEquals(1.0d, 1.0d, 0.0d);
259 }
260
261 @Test(expected = AssertionError.class)
262 public void notEqualsObjectWithNull() {
263 assertEquals(new Object(), null);
264 }
265
266 @Test(expected = AssertionError.class)
267 public void notEqualsNullWithObject() {
268 assertEquals(null, new Object());
269 }
270
271 @Test
272 public void notEqualsObjectWithNullWithMessage() {
273 Object o = new Object();
274 try {
275 assertEquals("message", null, o);
276 fail();
277 } catch (AssertionError e) {
278 assertEquals("message expected:<null> but was:<" + o.toString() + ">", e.getMessage());
279 }
280 }
281
282 @Test
283 public void notEqualsNullWithObjectWithMessage() {
284 Object o = new Object();
285 try {
286 assertEquals("message", o, null);
287 fail();
288 } catch (AssertionError e) {
289 assertEquals("message expected:<" + o.toString() + "> but was:<null>", e.getMessage());
290 }
291 }
292
293 @Test(expected = AssertionError.class)
294 public void objectsNotEquals() {
295 assertEquals(new Object(), new Object());
296 }
297
298 @Test(expected = ComparisonFailure.class)
299 public void stringsNotEqual() {
300 assertEquals("abc", "def");
301 }
302
303 @Test(expected = AssertionError.class)
304 public void booleansNotEqual() {
305 assertEquals(true, false);
306 }
307
308 @Test(expected = AssertionError.class)
309 public void bytesNotEqual() {
310 assertEquals((byte) 1, (byte) 2);
311 }
312
313 @Test(expected = AssertionError.class)
314 public void charsNotEqual() {
315 assertEquals('a', 'b');
316 }
317
318 @Test(expected = AssertionError.class)
319 public void shortsNotEqual() {
320 assertEquals((short) 1, (short) 2);
321 }
322
323 @Test(expected = AssertionError.class)
324 public void intsNotEqual() {
325 assertEquals(1, 2);
326 }
327
328 @Test(expected = AssertionError.class)
329 public void longsNotEqual() {
330 assertEquals(1l, 2l);
331 }
332
333 @Test(expected = AssertionError.class)
334 public void floatsNotEqual() {
335 assertEquals(1.0, 2.0, 0.9);
336 }
337
338 @SuppressWarnings("deprecation")
339 @Test(expected = AssertionError.class)
340 public void floatsNotEqualWithoutDelta() {
341 assertEquals(1.0, 1.1);
342 }
343
344 @Test
345 public void floatsNotDoublesInArrays() {
346 float delta = 4.444f;
347 float[] f1 = new float[]{1.111f};
348 float[] f2 = new float[]{5.555f};
349 Assert.assertArrayEquals(f1, f2, delta);
350 }
351
352 @Test(expected = AssertionError.class)
353 public void bigDecimalsNotEqual() {
354 assertEquals(new BigDecimal("123.4"), new BigDecimal("123.0"));
355 }
356
357
358 @Test(expected = AssertionError.class)
359 public void doublesNotEqual() {
360 assertEquals(1.0d, 2.0d, 0.9d);
361 }
362
363 @Test
364 public void naNsAreEqual() {
365 assertEquals(Float.NaN, Float.NaN, Float.POSITIVE_INFINITY);
366 assertEquals(Double.NaN, Double.NaN, Double.POSITIVE_INFINITY);
367 }
368
369 @Test
370 public void nullNullmessage() {
371 try {
372 assertNull("junit");
373 fail();
374 } catch (AssertionError e) {
375 assertEquals("expected null, but was:<junit>", e.getMessage());
376 }
377 }
378
379 @Test
380 public void nullWithMessage() {
381 try {
382 assertNull("message", "hello");
383 fail();
384 } catch (AssertionError exception) {
385 assertEquals("message expected null, but was:<hello>", exception.getMessage());
386 }
387 }
388
389 @Test
390 public void same() {
391 Object o1 = new Object();
392 assertSame(o1, o1);
393 }
394
395 @Test
396 public void notSame() {
397 Object o1 = new Object();
398 Object o2 = new Object();
399 assertNotSame(o1, o2);
400 }
401
402 @Test(expected = AssertionError.class)
403 public void objectsNotSame() {
404 assertSame(new Object(), new Object());
405 }
406
407 @Test(expected = AssertionError.class)
408 public void objectsAreSame() {
409 Object o = new Object();
410 assertNotSame(o, o);
411 }
412
413 @Test
414 public void sameWithMessage() {
415 try {
416 assertSame("not same", "hello", "good-bye");
417 fail();
418 } catch (AssertionError exception) {
419 assertEquals("not same expected same:<hello> was not:<good-bye>",
420 exception.getMessage());
421 }
422 }
423
424 @Test
425 public void sameNullMessage() {
426 try {
427 assertSame("hello", "good-bye");
428 fail();
429 } catch (AssertionError exception) {
430 assertEquals("expected same:<hello> was not:<good-bye>", exception.getMessage());
431 }
432 }
433
434 @Test
435 public void notSameWithMessage() {
436 Object o = new Object();
437 try {
438 assertNotSame("message", o, o);
439 fail();
440 } catch (AssertionError exception) {
441 assertEquals("message expected not same", exception.getMessage());
442 }
443 }
444
445 @Test
446 public void notSameNullMessage() {
447 Object o = new Object();
448 try {
449 assertNotSame(o, o);
450 fail();
451 } catch (AssertionError exception) {
452 assertEquals("expected not same", exception.getMessage());
453 }
454 }
455
456 @Test
457 public void nullMessage() {
458 try {
459 fail(null);
460 } catch (AssertionError exception) {
461
462 assertNull(exception.getMessage());
463 }
464 }
465
466 @Test
467 public void nullMessageDisappearsWithStringAssertEquals() {
468 try {
469 assertEquals(null, "a", "b");
470 fail();
471 } catch (ComparisonFailure e) {
472 assertEquals("expected:<[a]> but was:<[b]>", e.getMessage());
473 }
474 }
475
476 @Test
477 public void nullMessageDisappearsWithAssertEquals() {
478 try {
479 assertEquals(null, 1, 2);
480 fail();
481 } catch (AssertionError e) {
482 assertEquals("expected:<1> but was:<2>", e.getMessage());
483 }
484 }
485
486 @Test(expected = AssertionError.class)
487 public void arraysDeclaredAsObjectAreComparedAsObjects() {
488 Object a1 = new Object[]{"abc"};
489 Object a2 = new Object[]{"abc"};
490 assertEquals(a1, a2);
491 }
492
493 @Test
494 public void implicitTypecastEquality() {
495 byte b = 1;
496 short s = 1;
497 int i = 1;
498 long l = 1L;
499 float f = 1.0f;
500 double d = 1.0;
501
502 assertEquals(b, s);
503 assertEquals(b, i);
504 assertEquals(b, l);
505 assertEquals(s, i);
506 assertEquals(s, l);
507 assertEquals(i, l);
508 assertEquals(f, d, 0);
509 }
510
511 @Test
512 public void errorMessageDistinguishesDifferentValuesWithSameToString() {
513 try {
514 assertEquals("4", new Integer(4));
515 } catch (AssertionError e) {
516 assertEquals("expected: java.lang.String<4> but was: java.lang.Integer<4>", e.getMessage());
517 }
518 }
519
520 @Test
521 public void assertThatIncludesDescriptionOfTestedValueInErrorMessage() {
522 String expected = "expected";
523 String actual = "actual";
524
525 String expectedMessage = "identifier\nExpected: \"expected\"\n but: was \"actual\"";
526
527 try {
528 assertThat("identifier", actual, equalTo(expected));
529 } catch (AssertionError e) {
530 assertEquals(expectedMessage, e.getMessage());
531 }
532 }
533
534 @Test
535 public void assertThatIncludesAdvancedMismatch() {
536 String expectedMessage = "identifier\nExpected: is an instance of java.lang.Integer\n but: \"actual\" is a java.lang.String";
537
538 try {
539 assertThat("identifier", "actual", is(instanceOf(Integer.class)));
540 } catch (AssertionError e) {
541 assertEquals(expectedMessage, e.getMessage());
542 }
543 }
544
545 @Test
546 public void assertThatDescriptionCanBeElided() {
547 String expected = "expected";
548 String actual = "actual";
549
550 String expectedMessage = "\nExpected: \"expected\"\n but: was \"actual\"";
551
552 try {
553 assertThat(actual, equalTo(expected));
554 } catch (AssertionError e) {
555 assertEquals(expectedMessage, e.getMessage());
556 }
557 }
558
559 @Test
560 public void nullAndStringNullPrintCorrectError() {
561 try {
562 assertEquals(null, "null");
563 } catch (AssertionError e) {
564 assertEquals("expected: null<null> but was: java.lang.String<null>", e.getMessage());
565 }
566 }
567
568 @Test(expected = AssertionError.class)
569 public void stringNullAndNullWorksToo() {
570 assertEquals("null", null);
571 }
572
573 @Test(expected = AssertionError.class)
574 public void compareBigDecimalAndInteger() {
575 final BigDecimal bigDecimal = new BigDecimal("1.2");
576 final Integer integer = Integer.valueOf("1");
577 assertEquals(bigDecimal, integer);
578 }
579
580 @Test(expected = AssertionError.class)
581 public void sameObjectIsNotEqual() {
582 Object o = new Object();
583 assertNotEquals(o, o);
584 }
585
586 @Test
587 public void objectsWithDiferentReferencesAreNotEqual() {
588 assertNotEquals(new Object(), new Object());
589 }
590
591 @Test
592 public void assertNotEqualsIncludesCorrectMessage() {
593 Integer value1 = new Integer(1);
594 Integer value2 = new Integer(1);
595 String message = "The values should be different";
596
597 try {
598 assertNotEquals(message, value1, value2);
599 } catch (AssertionError e) {
600 assertEquals(message + ". Actual: " + value1, e.getMessage());
601 return;
602 }
603
604 fail("Failed on assertion.");
605 }
606
607 @Test
608 public void assertNotEqualsIncludesTheValueBeingTested() {
609 Integer value1 = new Integer(1);
610 Integer value2 = new Integer(1);
611
612 try {
613 assertNotEquals(value1, value2);
614 } catch (AssertionError e) {
615 assertTrue(e.getMessage().contains(value1.toString()));
616 return;
617 }
618
619 fail("Failed on assertion.");
620 }
621
622 @Test
623 public void assertNotEqualsWorksWithPrimitiveTypes() {
624 assertNotEquals(1L, 2L);
625 assertNotEquals("The values should be different", 1L, 2L);
626 assertNotEquals(1.0, 2.0, 0);
627 assertNotEquals("The values should be different", 1.0, 2.0, 0);
628 assertNotEquals(1.0f, 2.0f, 0f);
629 assertNotEquals("The values should be different", 1.0f, 2.0f, 0f);
630 }
631
632 @Test(expected = AssertionError.class)
633 public void assertNotEqualsConsidersDeltaCorrectly() {
634 assertNotEquals(1.0, 0.9, 0.1);
635 }
636
637 @Test(expected = AssertionError.class)
638 public void assertNotEqualsConsidersFloatDeltaCorrectly() {
639 assertNotEquals(1.0f, 0.75f, 0.25f);
640 }
641
642 @Test(expected = AssertionError.class)
643 public void assertNotEqualsIgnoresDeltaOnNaN() {
644 assertNotEquals(Double.NaN, Double.NaN, 1);
645 }
646
647 @Test(expected = AssertionError.class)
648 public void assertNotEqualsIgnoresFloatDeltaOnNaN() {
649 assertNotEquals(Float.NaN, Float.NaN, 1f);
650 }
651 }