package org.junit.tests.assertion;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.math.BigDecimal;
import org.junit.Assert;
import org.junit.ComparisonFailure;
import org.junit.Test;
import org.junit.internal.ArrayComparisonFailure;
/**
* Tests for {@link org.junit.Assert}
*/
public class AssertionTest {
// If you want to use 1.4 assertions, they will be reported correctly.
// However, you need to add the -ea VM argument when running.
// @Test (expected=AssertionError.class) public void error() {
// assert false;
// }
@Test(expected = AssertionError.class)
public void fails() {
Assert.fail();
}
@Test
public void failWithNoMessageToString() {
try {
Assert.fail();
} catch (AssertionError exception) {
assertEquals("java.lang.AssertionError", exception.toString());
}
}
@Test
public void failWithMessageToString() {
try {
Assert.fail("woops!");
} catch (AssertionError exception) {
assertEquals("java.lang.AssertionError: woops!", exception.toString());
}
}
@Test(expected = AssertionError.class)
public void arraysNotEqual() {
assertArrayEquals((new Object[]{new Object()}), (new Object[]{new Object()}));
}
@Test(expected = AssertionError.class)
public void arraysNotEqualWithMessage() {
assertArrayEquals("not equal", (new Object[]{new Object()}), (new Object[]{new Object()}));
}
@Test
public void arraysExpectedNullMessage() {
try {
assertArrayEquals("not equal", null, (new Object[]{new Object()}));
} catch (AssertionError exception) {
assertEquals("not equal: expected array was null", exception.getMessage());
}
}
@Test
public void arraysActualNullMessage() {
try {
assertArrayEquals("not equal", (new Object[]{new Object()}), null);
} catch (AssertionError exception) {
assertEquals("not equal: actual array was null", exception.getMessage());
}
}
@Test
public void arraysDifferentLengthMessage() {
try {
assertArrayEquals("not equal", (new Object[0]), (new Object[1]));
} catch (AssertionError exception) {
assertEquals("not equal: array lengths differed, expected.length=0 actual.length=1", exception.getMessage());
}
}
@Test(expected = ArrayComparisonFailure.class)
public void arraysElementsDiffer() {
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"}));
}
@Test
public void arraysDifferAtElement0nullMessage() {
try {
assertArrayEquals((new Object[]{true}), (new Object[]{false}));
} catch (AssertionError exception) {
assertEquals("arrays first differed at element [0]; expected:<true> but was:<false>", exception
.getMessage());
}
}
@Test
public void arraysDifferAtElement1nullMessage() {
try {
assertArrayEquals((new Object[]{true, true}), (new Object[]{true,
false}));
} catch (AssertionError exception) {
assertEquals("arrays first differed at element [1]; expected:<true> but was:<false>", exception
.getMessage());
}
}
@Test
public void arraysDifferAtElement0withMessage() {
try {
assertArrayEquals("message", (new Object[]{true}), (new Object[]{false}));
} catch (AssertionError exception) {
assertEquals("message: arrays first differed at element [0]; expected:<true> but was:<false>", exception
.getMessage());
}
}
@Test
public void arraysDifferAtElement1withMessage() {
try {
assertArrayEquals("message", (new Object[]{true, true}), (new Object[]{true, false}));
fail();
} catch (AssertionError exception) {
assertEquals("message: arrays first differed at element [1]; expected:<true> but was:<false>", exception.getMessage());
}
}
@Test
public void multiDimensionalArraysAreEqual() {
assertArrayEquals((new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {false, false}}));
}
@Test
public void multiDimensionalIntArraysAreEqual() {
int[][] int1 = {{1, 2, 3}, {4, 5, 6}};
int[][] int2 = {{1, 2, 3}, {4, 5, 6}};
assertArrayEquals(int1, int2);
}
@Test
public void oneDimensionalPrimitiveArraysAreEqual() {
assertArrayEquals(new boolean[]{true}, new boolean[]{true});
assertArrayEquals(new byte[]{1}, new byte[]{1});
assertArrayEquals(new char[]{1}, new char[]{1});
assertArrayEquals(new short[]{1}, new short[]{1});
assertArrayEquals(new int[]{1}, new int[]{1});
assertArrayEquals(new long[]{1}, new long[]{1});
assertArrayEquals(new double[]{1.0}, new double[]{1.0}, 1.0);
assertArrayEquals(new float[]{1.0f}, new float[]{1.0f}, 1.0f);
}
@Test(expected = AssertionError.class)
public void oneDimensionalDoubleArraysAreNotEqual() {
assertArrayEquals(new double[]{1.0}, new double[]{2.5}, 1.0);
}
@Test(expected = AssertionError.class)
public void oneDimensionalFloatArraysAreNotEqual() {
assertArrayEquals(new float[]{1.0f}, new float[]{2.5f}, 1.0f);
}
@Test(expected = AssertionError.class)
public void oneDimensionalBooleanArraysAreNotEqual() {
assertArrayEquals(new boolean[]{true}, new boolean[]{false});
}
@Test(expected = AssertionError.class)
public void IntegerDoesNotEqualLong() {
assertEquals(new Integer(1), new Long(1));
}
@Test
public void intsEqualLongs() {
assertEquals(1, 1L);
}
@Test
public void multiDimensionalArraysDeclaredAsOneDimensionalAreEqual() {
assertArrayEquals((new Object[]{new Object[]{true, true}, new Object[]{false, false}}), (new Object[]{new Object[]{true, true}, new Object[]{false, false}}));
}
@Test
public void multiDimensionalArraysAreNotEqual() {
try {
assertArrayEquals("message", (new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {true, false}}));
fail();
} catch (AssertionError exception) {
assertEquals("message: arrays first differed at element [1][0]; expected:<false> but was:<true>", exception.getMessage());
}
}
@Test
public void multiDimensionalArraysAreNotEqualNoMessage() {
try {
assertArrayEquals((new Object[][]{{true, true}, {false, false}}), (new Object[][]{{true, true}, {true, false}}));
fail();
} catch (AssertionError exception) {
assertEquals("arrays first differed at element [1][0]; expected:<false> but was:<true>", exception.getMessage());
}
}
@Test
public void arraysWithNullElementEqual() {
Object[] objects1 = new Object[]{null};
Object[] objects2 = new Object[]{null};
assertArrayEquals(objects1, objects2);
}
@Test
public void stringsDifferWithUserMessage() {
try {
assertEquals("not equal", "one", "two");
} catch (Throwable exception) {
assertEquals("not equal expected:<[one]> but was:<[two]>", exception.getMessage());
}
}
@Test
public void arraysEqual() {
Object element = new Object();
Object[] objects1 = new Object[]{element};
Object[] objects2 = new Object[]{element};
assertArrayEquals(objects1, objects2);
}
@Test
public void arraysEqualWithMessage() {
Object element = new Object();
Object[] objects1 = new Object[]{element};
Object[] objects2 = new Object[]{element};
assertArrayEquals("equal", objects1, objects2);
}
@Test
public void equals() {
Object o = new Object();
assertEquals(o, o);
assertEquals("abc", "abc");
assertEquals(true, true);
assertEquals((byte) 1, (byte) 1);
assertEquals('a', 'a');
assertEquals((short) 1, (short) 1);
assertEquals(1, 1); // int by default, cast is unnecessary
assertEquals(1l, 1l);
assertEquals(1.0, 1.0, 0.0);
assertEquals(1.0d, 1.0d, 0.0d);
}
@Test(expected = AssertionError.class)
public void notEqualsObjectWithNull() {
assertEquals(new Object(), null);
}
@Test(expected = AssertionError.class)
public void notEqualsNullWithObject() {
assertEquals(null, new Object());
}
@Test
public void notEqualsObjectWithNullWithMessage() {
Object o = new Object();
try {
assertEquals("message", null, o);
fail();
} catch (AssertionError e) {
assertEquals("message expected:<null> but was:<" + o.toString() + ">", e.getMessage());
}
}
@Test
public void notEqualsNullWithObjectWithMessage() {
Object o = new Object();
try {
assertEquals("message", o, null);
fail();
} catch (AssertionError e) {
assertEquals("message expected:<" + o.toString() + "> but was:<null>", e.getMessage());
}
}
@Test(expected = AssertionError.class)
public void objectsNotEquals() {
assertEquals(new Object(), new Object());
}
@Test(expected = ComparisonFailure.class)
public void stringsNotEqual() {
assertEquals("abc", "def");
}
@Test(expected = AssertionError.class)
public void booleansNotEqual() {
assertEquals(true, false);
}
@Test(expected = AssertionError.class)
public void bytesNotEqual() {
assertEquals((byte) 1, (byte) 2);
}
@Test(expected = AssertionError.class)
public void charsNotEqual() {
assertEquals('a', 'b');
}
@Test(expected = AssertionError.class)
public void shortsNotEqual() {
assertEquals((short) 1, (short) 2);
}
@Test(expected = AssertionError.class)
public void intsNotEqual() {
assertEquals(1, 2);
}
@Test(expected = AssertionError.class)
public void longsNotEqual() {
assertEquals(1l, 2l);
}
@Test(expected = AssertionError.class)
public void floatsNotEqual() {
assertEquals(1.0, 2.0, 0.9);
}
@SuppressWarnings("deprecation")
@Test(expected = AssertionError.class)
public void floatsNotEqualWithoutDelta() {
assertEquals(1.0, 1.1);
}
@Test
public void floatsNotDoublesInArrays() {
float delta = 4.444f;
float[] f1 = new float[]{1.111f};
float[] f2 = new float[]{5.555f};
Assert.assertArrayEquals(f1, f2, delta);
}
@Test(expected = AssertionError.class)
public void bigDecimalsNotEqual() {
assertEquals(new BigDecimal("123.4"), new BigDecimal("123.0"));
}
@Test(expected = AssertionError.class)
public void doublesNotEqual() {
assertEquals(1.0d, 2.0d, 0.9d);
}
@Test
public void naNsAreEqual() {
assertEquals(Float.NaN, Float.NaN, Float.POSITIVE_INFINITY);
assertEquals(Double.NaN, Double.NaN, Double.POSITIVE_INFINITY);
}
@Test
public void nullNullmessage() {
try {
assertNull("junit");
fail();
} catch (AssertionError e) {
assertEquals("expected null, but was:<junit>", e.getMessage());
}
}
@Test
public void nullWithMessage() {
try {
assertNull("message", "hello");
fail();
} catch (AssertionError exception) {
assertEquals("message expected null, but was:<hello>", exception.getMessage());
}
}
@Test
public void same() {
Object o1 = new Object();
assertSame(o1, o1);
}
@Test
public void notSame() {
Object o1 = new Object();
Object o2 = new Object();
assertNotSame(o1, o2);
}
@Test(expected = AssertionError.class)
public void objectsNotSame() {
assertSame(new Object(), new Object());
}
@Test(expected = AssertionError.class)
public void objectsAreSame() {
Object o = new Object();
assertNotSame(o, o);
}
@Test
public void sameWithMessage() {
try {
assertSame("not same", "hello", "good-bye");
fail();
} catch (AssertionError exception) {
assertEquals("not same expected same:<hello> was not:<good-bye>",
exception.getMessage());
}
}
@Test
public void sameNullMessage() {
try {
assertSame("hello", "good-bye");
fail();
} catch (AssertionError exception) {
assertEquals("expected same:<hello> was not:<good-bye>", exception.getMessage());
}
}
@Test
public void notSameWithMessage() {
Object o = new Object();
try {
assertNotSame("message", o, o);
fail();
} catch (AssertionError exception) {
assertEquals("message expected not same", exception.getMessage());
}
}
@Test
public void notSameNullMessage() {
Object o = new Object();
try {
assertNotSame(o, o);
fail();
} catch (AssertionError exception) {
assertEquals("expected not same", exception.getMessage());
}
}
@Test
public void nullMessage() {
try {
fail(null);
} catch (AssertionError exception) {
// we used to expect getMessage() to return ""; see failWithNoMessageToString()
assertNull(exception.getMessage());
}
}
@Test
public void nullMessageDisappearsWithStringAssertEquals() {
try {
assertEquals(null, "a", "b");
fail();
} catch (ComparisonFailure e) {
assertEquals("expected:<[a]> but was:<[b]>", e.getMessage());
}
}
@Test
public void nullMessageDisappearsWithAssertEquals() {
try {
assertEquals(null, 1, 2);
fail();
} catch (AssertionError e) {
assertEquals("expected:<1> but was:<2>", e.getMessage());
}
}
@Test(expected = AssertionError.class)
public void arraysDeclaredAsObjectAreComparedAsObjects() {
Object a1 = new Object[]{"abc"};
Object a2 = new Object[]{"abc"};
assertEquals(a1, a2);
}
@Test
public void implicitTypecastEquality() {
byte b = 1;
short s = 1;
int i = 1;
long l = 1L;
float f = 1.0f;
double d = 1.0;
assertEquals(b, s);
assertEquals(b, i);
assertEquals(b, l);
assertEquals(s, i);
assertEquals(s, l);
assertEquals(i, l);
assertEquals(f, d, 0);
}
@Test
public void errorMessageDistinguishesDifferentValuesWithSameToString() {
try {
assertEquals("4", new Integer(4));
} catch (AssertionError e) {
assertEquals("expected: java.lang.String<4> but was: java.lang.Integer<4>", e.getMessage());
}
}
@Test
public void assertThatIncludesDescriptionOfTestedValueInErrorMessage() {
String expected = "expected";
String actual = "actual";
String expectedMessage = "identifier\nExpected: \"expected\"\n but: was \"actual\"";
try {
assertThat("identifier", actual, equalTo(expected));
} catch (AssertionError e) {
assertEquals(expectedMessage, e.getMessage());
}
}
@Test
public void assertThatIncludesAdvancedMismatch() {
String expectedMessage = "identifier\nExpected: is an instance of java.lang.Integer\n but: \"actual\" is a java.lang.String";
try {
assertThat("identifier", "actual", is(instanceOf(Integer.class)));
} catch (AssertionError e) {
assertEquals(expectedMessage, e.getMessage());
}
}
@Test
public void assertThatDescriptionCanBeElided() {
String expected = "expected";
String actual = "actual";
String expectedMessage = "\nExpected: \"expected\"\n but: was \"actual\"";
try {
assertThat(actual, equalTo(expected));
} catch (AssertionError e) {
assertEquals(expectedMessage, e.getMessage());
}
}
@Test
public void nullAndStringNullPrintCorrectError() {
try {
assertEquals(null, "null");
} catch (AssertionError e) {
assertEquals("expected: null<null> but was: java.lang.String<null>", e.getMessage());
}
}
@Test(expected = AssertionError.class)
public void stringNullAndNullWorksToo() {
assertEquals("null", null);
}
@Test(expected = AssertionError.class)
public void compareBigDecimalAndInteger() {
final BigDecimal bigDecimal = new BigDecimal("1.2");
final Integer integer = Integer.valueOf("1");
assertEquals(bigDecimal, integer);
}
@Test(expected = AssertionError.class)
public void sameObjectIsNotEqual() {
Object o = new Object();
assertNotEquals(o, o);
}
@Test
public void objectsWithDiferentReferencesAreNotEqual() {
assertNotEquals(new Object(), new Object());
}
@Test
public void assertNotEqualsIncludesCorrectMessage() {
Integer value1 = new Integer(1);
Integer value2 = new Integer(1);
String message = "The values should be different";
try {
assertNotEquals(message, value1, value2);
} catch (AssertionError e) {
assertEquals(message + ". Actual: " + value1, e.getMessage());
return;
}
fail("Failed on assertion.");
}
@Test
public void assertNotEqualsIncludesTheValueBeingTested() {
Integer value1 = new Integer(1);
Integer value2 = new Integer(1);
try {
assertNotEquals(value1, value2);
} catch (AssertionError e) {
assertTrue(e.getMessage().contains(value1.toString()));
return;
}
fail("Failed on assertion.");
}
@Test
public void assertNotEqualsWorksWithPrimitiveTypes() {
assertNotEquals(1L, 2L);
assertNotEquals("The values should be different", 1L, 2L);
assertNotEquals(1.0, 2.0, 0);
assertNotEquals("The values should be different", 1.0, 2.0, 0);
assertNotEquals(1.0f, 2.0f, 0f);
assertNotEquals("The values should be different", 1.0f, 2.0f, 0f);
}
@Test(expected = AssertionError.class)
public void assertNotEqualsConsidersDeltaCorrectly() {
assertNotEquals(1.0, 0.9, 0.1);
}
@Test(expected = AssertionError.class)
public void assertNotEqualsConsidersFloatDeltaCorrectly() {
assertNotEquals(1.0f, 0.75f, 0.25f);
}
@Test(expected = AssertionError.class)
public void assertNotEqualsIgnoresDeltaOnNaN() {
assertNotEquals(Double.NaN, Double.NaN, 1);
}
@Test(expected = AssertionError.class)
public void assertNotEqualsIgnoresFloatDeltaOnNaN() {
assertNotEquals(Float.NaN, Float.NaN, 1f);
}
}