    001    package junit.framework;
    002
    003    /**
    004     * A set of assert methods.  Messages are only displayed when an assert fails.
    005     *
    006     * @deprecated Please use {@link org.junit.Assert} instead.
    007     */
    008    @Deprecated
    009    public class Assert {
    010        /**
    011         * Protect constructor since it is a static only class
    012         */
    013        protected Assert() {
    014        }
    015
    016        /**
    017         * Asserts that a condition is true. If it isn't it throws
    018         * an AssertionFailedError with the given message.
    019         */
    020        static public void assertTrue(String message, boolean condition) {
    021            if (!condition) {
    022                fail(message);
    023            }
    024        }
    025
    026        /**
    027         * Asserts that a condition is true. If it isn't it throws
    028         * an AssertionFailedError.
    029         */
    030        static public void assertTrue(boolean condition) {
    031            assertTrue(null, condition);
    032        }
    033
    034        /**
    035         * Asserts that a condition is false. If it isn't it throws
    036         * an AssertionFailedError with the given message.
    037         */
    038        static public void assertFalse(String message, boolean condition) {
    039            assertTrue(message, !condition);
    040        }
    041
    042        /**
    043         * Asserts that a condition is false. If it isn't it throws
    044         * an AssertionFailedError.
    045         */
    046        static public void assertFalse(boolean condition) {
    047            assertFalse(null, condition);
    048        }
    049
    050        /**
    051         * Fails a test with the given message.
    052         */
    053        static public void fail(String message) {
    054            if (message == null) {
    055                throw new AssertionFailedError();
    056            }
    057            throw new AssertionFailedError(message);
    058        }
    059
    060        /**
    061         * Fails a test with no message.
    062         */
    063        static public void fail() {
    064            fail(null);
    065        }
    066
    067        /**
    068         * Asserts that two objects are equal. If they are not
    069         * an AssertionFailedError is thrown with the given message.
    070         */
    071        static public void assertEquals(String message, Object expected, Object actual) {
    072            if (expected == null && actual == null) {
    073                return;
    074            }
    075            if (expected != null && expected.equals(actual)) {
    076                return;
    077            }
    078            failNotEquals(message, expected, actual);
    079        }
    080
    081        /**
    082         * Asserts that two objects are equal. If they are not
    083         * an AssertionFailedError is thrown.
    084         */
    085        static public void assertEquals(Object expected, Object actual) {
    086            assertEquals(null, expected, actual);
    087        }
    088
    089        /**
    090         * Asserts that two Strings are equal.
    091         */
    092        static public void assertEquals(String message, String expected, String actual) {
    093            if (expected == null && actual == null) {
    094                return;
    095            }
    096            if (expected != null && expected.equals(actual)) {
    097                return;
    098            }
    099            String cleanMessage = message == null ? "" : message;
    100            throw new ComparisonFailure(cleanMessage, expected, actual);
    101        }
    102
    103        /**
    104         * Asserts that two Strings are equal.
    105         */
    106        static public void assertEquals(String expected, String actual) {
    107            assertEquals(null, expected, actual);
    108        }
    109
    110        /**
    111         * Asserts that two doubles are equal concerning a delta.  If they are not
    112         * an AssertionFailedError is thrown with the given message.  If the expected
    113         * value is infinity then the delta value is ignored.
    114         */
    115        static public void assertEquals(String message, double expected, double actual, double delta) {
    116            if (Double.compare(expected, actual) == 0) {
    117                return;
    118            }
    119            if (!(Math.abs(expected - actual) <= delta)) {
    120                failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual));
    121            }
    122        }
    123
    124        /**
    125         * Asserts that two doubles are equal concerning a delta. If the expected
    126         * value is infinity then the delta value is ignored.
    127         */
    128        static public void assertEquals(double expected, double actual, double delta) {
    129            assertEquals(null, expected, actual, delta);
    130        }
    131
    132        /**
    133         * Asserts that two floats are equal concerning a positive delta. If they
    134         * are not an AssertionFailedError is thrown with the given message. If the
    135         * expected value is infinity then the delta value is ignored.
    136         */
    137        static public void assertEquals(String message, float expected, float actual, float delta) {
    138            if (Float.compare(expected, actual) == 0) {
    139                return;
    140            }
    141            if (!(Math.abs(expected - actual) <= delta)) {
    142                failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
    143            }
    144        }
    145
    146        /**
    147         * Asserts that two floats are equal concerning a delta. If the expected
    148         * value is infinity then the delta value is ignored.
    149         */
    150        static public void assertEquals(float expected, float actual, float delta) {
    151            assertEquals(null, expected, actual, delta);
    152        }
    153
    154        /**
    155         * Asserts that two longs are equal. If they are not
    156         * an AssertionFailedError is thrown with the given message.
    157         */
    158        static public void assertEquals(String message, long expected, long actual) {
    159            assertEquals(message, Long.valueOf(expected), Long.valueOf(actual));
    160        }
    161
    162        /**
    163         * Asserts that two longs are equal.
    164         */
    165        static public void assertEquals(long expected, long actual) {
    166            assertEquals(null, expected, actual);
    167        }
    168
    169        /**
    170         * Asserts that two booleans are equal. If they are not
    171         * an AssertionFailedError is thrown with the given message.
    172         */
    173        static public void assertEquals(String message, boolean expected, boolean actual) {
    174            assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
    175        }
    176
    177        /**
    178         * Asserts that two booleans are equal.
    179         */
    180        static public void assertEquals(boolean expected, boolean actual) {
    181            assertEquals(null, expected, actual);
    182        }
    183
    184        /**
    185         * Asserts that two bytes are equal. If they are not
    186         * an AssertionFailedError is thrown with the given message.
    187         */
    188        static public void assertEquals(String message, byte expected, byte actual) {
    189            assertEquals(message, Byte.valueOf(expected), Byte.valueOf(actual));
    190        }
    191
    192        /**
    193         * Asserts that two bytes are equal.
    194         */
    195        static public void assertEquals(byte expected, byte actual) {
    196            assertEquals(null, expected, actual);
    197        }
    198
    199        /**
    200         * Asserts that two chars are equal. If they are not
    201         * an AssertionFailedError is thrown with the given message.
    202         */
    203        static public void assertEquals(String message, char expected, char actual) {
    204            assertEquals(message, Character.valueOf(expected), Character.valueOf(actual));
    205        }
    206
    207        /**
    208         * Asserts that two chars are equal.
    209         */
    210        static public void assertEquals(char expected, char actual) {
    211            assertEquals(null, expected, actual);
    212        }
    213
    214        /**
    215         * Asserts that two shorts are equal. If they are not
    216         * an AssertionFailedError is thrown with the given message.
    217         */
    218        static public void assertEquals(String message, short expected, short actual) {
    219            assertEquals(message, Short.valueOf(expected), Short.valueOf(actual));
    220        }
    221
    222        /**
    223         * Asserts that two shorts are equal.
    224         */
    225        static public void assertEquals(short expected, short actual) {
    226            assertEquals(null, expected, actual);
    227        }
    228
    229        /**
    230         * Asserts that two ints are equal. If they are not
    231         * an AssertionFailedError is thrown with the given message.
    232         */
    233        static public void assertEquals(String message, int expected, int actual) {
    234            assertEquals(message, Integer.valueOf(expected), Integer.valueOf(actual));
    235        }
    236
    237        /**
    238         * Asserts that two ints are equal.
    239         */
    240        static public void assertEquals(int expected, int actual) {
    241            assertEquals(null, expected, actual);
    242        }
    243
    244        /**
    245         * Asserts that an object isn't null.
    246         */
    247        static public void assertNotNull(Object object) {
    248            assertNotNull(null, object);
    249        }
    250
    251        /**
    252         * Asserts that an object isn't null. If it is
    253         * an AssertionFailedError is thrown with the given message.
    254         */
    255        static public void assertNotNull(String message, Object object) {
    256            assertTrue(message, object != null);
    257        }
    258
    259        /**
    260         * Asserts that an object is null. If it isn't an {@link AssertionError} is
    261         * thrown.
    262         * Message contains: Expected: <null> but was: object
    263         *
    264         * @param object Object to check or <code>null</code>
    265         */
    266        static public void assertNull(Object object) {
    267            if (object != null) {
    268                assertNull("Expected: <null> but was: " + object.toString(), object);
    269            }
    270        }
    271
    272        /**
    273         * Asserts that an object is null.  If it is not
    274         * an AssertionFailedError is thrown with the given message.
    275         */
    276        static public void assertNull(String message, Object object) {
    277            assertTrue(message, object == null);
    278        }
    279
    280        /**
    281         * Asserts that two objects refer to the same object. If they are not
    282         * an AssertionFailedError is thrown with the given message.
    283         */
    284        static public void assertSame(String message, Object expected, Object actual) {
    285            if (expected == actual) {
    286                return;
    287            }
    288            failNotSame(message, expected, actual);
    289        }
    290
    291        /**
    292         * Asserts that two objects refer to the same object. If they are not
    293         * the same an AssertionFailedError is thrown.
    294         */
    295        static public void assertSame(Object expected, Object actual) {
    296            assertSame(null, expected, actual);
    297        }
    298
    299        /**
    300         * Asserts that two objects do not refer to the same object. If they do
    301         * refer to the same object an AssertionFailedError is thrown with the
    302         * given message.
    303         */
    304        static public void assertNotSame(String message, Object expected, Object actual) {
    305            if (expected == actual) {
    306                failSame(message);
    307            }
    308        }
    309
    310        /**
    311         * Asserts that two objects do not refer to the same object. If they do
    312         * refer to the same object an AssertionFailedError is thrown.
    313         */
    314        static public void assertNotSame(Object expected, Object actual) {
    315            assertNotSame(null, expected, actual);
    316        }
    317
    318        static public void failSame(String message) {
    319            String formatted = (message != null) ? message + " " : "";
    320            fail(formatted + "expected not same");
    321        }
    322
    323        static public void failNotSame(String message, Object expected, Object actual) {
    324            String formatted = (message != null) ? message + " " : "";
    325            fail(formatted + "expected same:<" + expected + "> was not:<" + actual + ">");
    326        }
    327
    328        static public void failNotEquals(String message, Object expected, Object actual) {
    329            fail(format(message, expected, actual));
    330        }
    331
    332        public static String format(String message, Object expected, Object actual) {
    333            String formatted = "";
    334            if (message != null && message.length() > 0) {
    335                formatted = message + " ";
    336            }
    337            return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
    338        }
    339    }