AssertionTest.java

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.assertThrows;
import static org.junit.Assert.fail;

import java.io.IOException;
import java.math.BigDecimal;

import org.junit.Assert;
import org.junit.ComparisonFailure;
import org.junit.Test;
import org.junit.function.ThrowingRunnable;
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;
//  }

    private static final String ASSERTION_ERROR_EXPECTED = "AssertionError expected";

    @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());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void failWithMessageToString() {
        try {
            Assert.fail("woops!");
        } catch (AssertionError exception) {
            assertEquals("java.lang.AssertionError: woops!", exception.toString());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void arraysNotEqual() {
        assertArrayEqualsFailure(
                new Object[]{"right"},
                new Object[]{"wrong"},
                "arrays first differed at element [0]; expected:<[right]> but was:<[wrong]>");
    }

    @Test
    public void arraysNotEqualWithMessage() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[]{"right"},
                new Object[]{"wrong"},
                "not equal: arrays first differed at element [0]; expected:<[right]> but was:<[wrong]>");
    }

    @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());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void arraysDifferentLengthDifferingAtStartMessage() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[]{true},
                new Object[]{false, true},
                "not equal: array lengths differed, expected.length=1 actual.length=2; arrays first differed at element [0]; expected:<true> but was:<false>");
    }

    @Test
    public void arraysDifferentLengthDifferingAtEndMessage() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[]{true},
                new Object[]{true, false},
                "not equal: array lengths differed, expected.length=1 actual.length=2; arrays first differed at element [1]; expected:<end of array> but was:<false>");
    }

    @Test
    public void arraysDifferentLengthDifferingAtEndAndExpectedArrayLongerMessage() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[]{true, false},
                new Object[]{true},
                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<false> but was:<end of array>");
    }

    @Test
    public void arraysElementsDiffer() {
        assertArrayEqualsFailure(
                "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"},
                "not equal: arrays first differed at element [0]; expected:<this is a[] very long string in...> but was:<this is a[nother] very long string in...>");
    }

    @Test
    public void arraysDifferAtElement0nullMessage() {
        assertArrayEqualsFailure(
                new Object[]{true},
                new Object[]{false},
                "arrays first differed at element [0]; expected:<true> but was:<false>"
        );
    }

    @Test
    public void arraysDifferAtElement1nullMessage() {
        assertArrayEqualsFailure(
                new Object[]{true, true},
                new Object[]{true, false},
                "arrays first differed at element [1]; expected:<true> but was:<false>"
        );
    }

    @Test
    public void arraysDifferAtElement0withMessage() {
        assertArrayEqualsFailure(
                "message",
                new Object[]{true},
                new Object[]{false},
                "message: arrays first differed at element [0]; expected:<true> but was:<false>"
        );
    }

    @Test
    public void arraysDifferAtElement1withMessage() {
        assertArrayEqualsFailure(
                "message",
                new Object[]{true, true},
                new Object[]{true, false},
                "message: arrays first differed at element [1]; expected:<true> but was:<false>"
        );
    }

    @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(Integer.valueOf(1), Long.valueOf(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() {
        assertArrayEqualsFailure(
                "message",
                new Object[][]{{true, true}, {false, false}},
                new Object[][]{{true, true}, {true, false}},
                "message: arrays first differed at element [1][0]; expected:<false> but was:<true>");
    }

    @Test
    public void multiDimensionalArraysAreNotEqualNoMessage() {
        assertArrayEqualsFailure(
                new Object[][]{{true, true}, {false, false}},
                new Object[][]{{true, true}, {true, false}},
                "arrays first differed at element [1][0]; expected:<false> but was:<true>");
    }

    @Test
    public void twoDimensionalArraysDifferentOuterLengthNotEqual() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{true}, {}},
                new Object[][]{{}},
                "not equal: array lengths differed, expected.length=1 actual.length=0; arrays first differed at element [0][0]; expected:<true> but was:<end of array>");
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{}, {true}},
                new Object[][]{{}},
                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<java.lang.Object[1]> but was:<end of array>");
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{}},
                new Object[][]{{true}, {}},
                "not equal: array lengths differed, expected.length=0 actual.length=1; arrays first differed at element [0][0]; expected:<end of array> but was:<true>");
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{}},
                new Object[][]{{}, {true}},
                "not equal: array lengths differed, expected.length=1 actual.length=2; arrays first differed at element [1]; expected:<end of array> but was:<java.lang.Object[1]>");
    }

    @Test
    public void primitiveArraysConvertedToStringCorrectly() {
        assertArrayEqualsFailure(
                "not equal",
                new boolean[][]{{}, {true}},
                new boolean[][]{{}},
                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<boolean[1]> but was:<end of array>");
        assertArrayEqualsFailure(
                "not equal",
                new int[][]{{}, {23}},
                new int[][]{{}},
                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<int[1]> but was:<end of array>");
    }

    @Test
    public void twoDimensionalArraysConvertedToStringCorrectly() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[][][]{{}, {{true}}},
                new Object[][][]{{}},
                "not equal: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1]; expected:<java.lang.Object[][1]> but was:<end of array>");
    }

    @Test
    public void twoDimensionalArraysDifferentInnerLengthNotEqual() {
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{true}, {}},
                new Object[][]{{}, {}},
                "not equal: array lengths differed, expected.length=1 actual.length=0; arrays first differed at element [0][0]; expected:<true> but was:<end of array>");
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{}, {true}},
                new Object[][]{{}, {}},
                "not equal: array lengths differed, expected.length=1 actual.length=0; arrays first differed at element [1][0]; expected:<true> but was:<end of array>");
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{}, {}},
                new Object[][]{{true}, {}},
                "not equal: array lengths differed, expected.length=0 actual.length=1; arrays first differed at element [0][0]; expected:<end of array> but was:<true>");
        assertArrayEqualsFailure(
                "not equal",
                new Object[][]{{}, {}},
                new Object[][]{{}, {true}},
                "not equal: array lengths differed, expected.length=0 actual.length=1; arrays first differed at element [1][0]; expected:<end of array> but was:<true>");
    }

    private void assertArrayEqualsFailure(Object[] expecteds, Object[] actuals, String expectedMessage) {
        try {
            assertArrayEquals(expecteds, actuals);
        } catch (ArrayComparisonFailure e) {
            assertEquals(expectedMessage, e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    private void assertArrayEqualsFailure(String message, Object[] expecteds, Object[] actuals, String expectedMessage) {
        try {
            assertArrayEquals(message, expecteds, actuals);
        } catch (ArrayComparisonFailure e) {
            assertEquals(expectedMessage, e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void multiDimensionalArraysDifferentLengthMessage() {
        try {
            assertArrayEquals("message", new Object[][]{{true, true}, {false, false}}, new Object[][]{{true, true}, {false}});
        } catch (AssertionError exception) {
            assertEquals("message: array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1][1]; expected:<false> but was:<end of array>", exception.getMessage());
            return;
        }

        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void multiDimensionalArraysDifferentLengthNoMessage() {
        try {
            assertArrayEquals(new Object[][]{{true, true}, {false, false}}, new Object[][]{{true, true}, {false}});
        } catch (AssertionError exception) {
            assertEquals("array lengths differed, expected.length=2 actual.length=1; arrays first differed at element [1][1]; expected:<false> but was:<end of array>", exception.getMessage());
            return;
        }

        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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 (ComparisonFailure exception) {
            assertEquals("not equal expected:<[one]> but was:<[two]>", exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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);
        } catch (AssertionError e) {
            assertEquals("message expected:<null> but was:<" + o.toString() + ">", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void notEqualsNullWithObjectWithMessage() {
        Object o = new Object();
        try {
            assertEquals("message", o, null);
        } catch (AssertionError e) {
            assertEquals("message expected:<" + o.toString() + "> but was:<null>", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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);
    }

    @SuppressWarnings("unused")
    @Test
    public void nullNullmessage() {
        try {
            assertNull("junit");
        } catch (AssertionError e) {
            assertEquals("expected null, but was:<junit>", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @SuppressWarnings("unused")
    @Test
    public void nullWithMessage() {
        try {
            assertNull("message", "hello");
        } catch (AssertionError exception) {
            assertEquals("message expected null, but was:<hello>", exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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");
        } catch (AssertionError exception) {
            assertEquals("not same expected same:<hello> was not:<good-bye>",
                    exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void sameNullMessage() {
        try {
            assertSame("hello", "good-bye");
        } catch (AssertionError exception) {
            assertEquals("expected same:<hello> was not:<good-bye>", exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void notSameWithMessage() {
        Object o = new Object();
        try {
            assertNotSame("message", o, o);
        } catch (AssertionError exception) {
            assertEquals("message expected not same", exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void notSameNullMessage() {
        Object o = new Object();
        try {
            assertNotSame(o, o);
        } catch (AssertionError exception) {
            assertEquals("expected not same", exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void nullMessage() {
        try {
            fail(null);
        } catch (AssertionError exception) {
            // we used to expect getMessage() to return ""; see failWithNoMessageToString()
            assertNull(exception.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void nullMessageDisappearsWithStringAssertEquals() {
        try {
            assertEquals(null, "a", "b");
        } catch (ComparisonFailure e) {
            assertEquals("expected:<[a]> but was:<[b]>", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void nullMessageDisappearsWithAssertEquals() {
        try {
            assertEquals(null, 1, 2);
        } catch (AssertionError e) {
            assertEquals("expected:<1> but was:<2>", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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", Integer.valueOf(4));
        } catch (AssertionError e) {
            assertEquals("expected: java.lang.String<4> but was: java.lang.Integer<4>", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void nullAndStringNullPrintCorrectError() {
        try {
            assertEquals(null, "null");
        } catch (AssertionError e) {
            assertEquals("expected: null<null> but was: java.lang.String<null>", e.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test(expected = AssertionError.class)
    public void stringNullAndNullWorksToo() {
        assertEquals("null", null);
    }

    private static class NullToString {
        @Override
        public String toString() {
            return null;
        }
    }

    @Test
    public void nullToString() {
        try {
            assertEquals(new NullToString(), new NullToString());
        } catch (AssertionError e) {
            assertEquals("expected: org.junit.tests.assertion.AssertionTest$NullToString<null> but "
                            + "was: org.junit.tests.assertion.AssertionTest$NullToString<null>",
                    e.getMessage());
            return;
        }

        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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 objectsWithDifferentReferencesAreNotEqual() {
        assertNotEquals(new Object(), new Object());
    }

    @Test
    public void assertNotEqualsIncludesCorrectMessage() {
        Integer value1 = 1;
        Integer value2 = 1;
        String message = "The values should be different";

        try {
            assertNotEquals(message, value1, value2);
        } catch (AssertionError e) {
            assertEquals(message + ". Actual: " + value1, e.getMessage());
            return;
        }

        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertNotEqualsIncludesTheValueBeingTested() {
        Integer value1 = 1;
        Integer value2 = 1;

        try {
            assertNotEquals(value1, value2);
        } catch (AssertionError e) {
            assertTrue(e.getMessage().contains(value1.toString()));
            return;
        }

        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @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);
    }

    @Test(expected = AssertionError.class)
    public void assertThrowsRequiresAnExceptionToBeThrown() {
        assertThrows(Throwable.class, nonThrowingRunnable());
    }

    @Test
    public void assertThrowsIncludesAnInformativeDefaultMessage() {
        try {
            assertThrows(Throwable.class, nonThrowingRunnable());
        } catch (AssertionError ex) {
            assertEquals("expected java.lang.Throwable to be thrown, but nothing was thrown", ex.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsIncludesTheSpecifiedMessage() {
        try {
            assertThrows("Foobar", Throwable.class, nonThrowingRunnable());
        } catch (AssertionError ex) {
            assertEquals(
                    "Foobar: expected java.lang.Throwable to be thrown, but nothing was thrown",
                    ex.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsReturnsTheSameObjectThrown() {
        NullPointerException npe = new NullPointerException();

        Throwable throwable = assertThrows(Throwable.class, throwingRunnable(npe));

        assertSame(npe, throwable);
    }

    @Test(expected = AssertionError.class)
    public void assertThrowsDetectsTypeMismatchesViaExplicitTypeHint() {
        NullPointerException npe = new NullPointerException();

        assertThrows(IOException.class, throwingRunnable(npe));
    }

    @Test
    public void assertThrowsWrapsAndPropagatesUnexpectedExceptions() {
        NullPointerException npe = new NullPointerException("inner-message");

        try {
            assertThrows(IOException.class, throwingRunnable(npe));
        } catch (AssertionError ex) {
            assertSame(npe, ex.getCause());
            assertEquals("inner-message", ex.getCause().getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsSuppliesACoherentErrorMessageUponTypeMismatch() {
        NullPointerException npe = new NullPointerException();

        try {
            assertThrows(IOException.class, throwingRunnable(npe));
        } catch (AssertionError error) {
            assertEquals("unexpected exception type thrown; expected:<java.io.IOException> but was:<java.lang.NullPointerException>",
                    error.getMessage());
            assertSame(npe, error.getCause());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsSuppliesTheSpecifiedMessageUponTypeMismatch() {
        NullPointerException npe = new NullPointerException();

        try {
            assertThrows("Foobar", IOException.class, throwingRunnable(npe));
        } catch (AssertionError error) {
            assertEquals("Foobar: unexpected exception type thrown; expected:<java.io.IOException> but was:<java.lang.NullPointerException>",
                    error.getMessage());
            assertSame(npe, error.getCause());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsUsesCanonicalNameUponTypeMismatch() {
        NullPointerException npe = new NullPointerException();

        try {
            assertThrows(NestedException.class, throwingRunnable(npe));
        } catch (AssertionError error) {
            assertEquals(
                    "unexpected exception type thrown; expected:<org.junit.tests.assertion.AssertionTest.NestedException>"
                    + " but was:<java.lang.NullPointerException>",
                    error.getMessage());
            assertSame(npe, error.getCause());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsUsesNameUponTypeMismatchWithAnonymousClass() {
        NullPointerException npe = new NullPointerException() {
        };

        try {
            assertThrows(IOException.class, throwingRunnable(npe));
        } catch (AssertionError error) {
            assertEquals(
                    "unexpected exception type thrown; expected:<java.io.IOException>"
                    + " but was:<org.junit.tests.assertion.AssertionTest$1>",
                    error.getMessage());
            assertSame(npe, error.getCause());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    @Test
    public void assertThrowsUsesCanonicalNameWhenRequiredExceptionNotThrown() {
        try {
            assertThrows(NestedException.class, nonThrowingRunnable());
        } catch (AssertionError error) {
            assertEquals(
                    "expected org.junit.tests.assertion.AssertionTest.NestedException to be thrown,"
                    + " but nothing was thrown", error.getMessage());
            return;
        }
        throw new AssertionError(ASSERTION_ERROR_EXPECTED);
    }

    private static class NestedException extends RuntimeException {
        private static final long serialVersionUID = 1L;
    }

    private static ThrowingRunnable nonThrowingRunnable() {
        return new ThrowingRunnable() {
            public void run() throws Throwable {
            }
        };
    }

    private static ThrowingRunnable throwingRunnable(final Throwable t) {
        return new ThrowingRunnable() {
            public void run() throws Throwable {
                throw t;
            }
        };
    }
}