Junit的Assert用法

 package junit.framework;

 /**
  * A set of assert methods.  Messages are only displayed when an assert fails.
  */

 public class Assert {
     /**
      * Protect constructor since it is a static only class
      */
     protected Assert() {
     }

     /**
      * Asserts that a condition is true. If it isn't it throws
      * an AssertionFailedError with the given message.
      */
     static public void assertTrue(String message, boolean condition) {
         if (!condition)
             fail(message);
     }
     /**
      * Asserts that a condition is true. If it isn't it throws
      * an AssertionFailedError.
      */
     static public void assertTrue(boolean condition) {
         assertTrue(null, condition);
     }
     /**
      * Asserts that a condition is false. If it isn't it throws
      * an AssertionFailedError with the given message.
      */
     static public void assertFalse(String message, boolean condition) {
         assertTrue(message, !condition);
     }
     /**
      * Asserts that a condition is false. If it isn't it throws
      * an AssertionFailedError.
      */
     static public void assertFalse(boolean condition) {
         assertFalse(null, condition);
     }
     /**
      * Fails a test with the given message.
      */
     static public void fail(String message) {
         if (message == null) {
             throw new AssertionFailedError();
         }
         throw new AssertionFailedError(message);
     }
     /**
      * Fails a test with no message.
      */
     static public void fail() {
         fail(null);
     }
     /**
      * Asserts that two objects are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertEquals(String message, Object expected, Object actual) {
         if (expected == null && actual == null)
             return;
         if (expected != null && expected.equals(actual))
             return;
         failNotEquals(message, expected, actual);
     }
     /**
      * Asserts that two objects are equal. If they are not
      * an AssertionFailedError is thrown.
      */
     static public void assertEquals(Object expected, Object actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two Strings are equal.
      */
     static public void assertEquals(String message, String expected, String actual) {
         if (expected == null && actual == null)
             return;
         if (expected != null && expected.equals(actual))
             return;
         String cleanMessage= message == null ? "" : message;
         throw new ComparisonFailure(cleanMessage, expected, actual);
     }
     /**
      * Asserts that two Strings are equal.
      */
     static public void assertEquals(String expected, String actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two doubles are equal concerning a delta.  If they are not
      * an AssertionFailedError is thrown with the given message.  If the expected
      * value is infinity then the delta value is ignored.
      */
     static public void assertEquals(String message, double expected, double actual, double delta) {
         if (Double.compare(expected, actual) == 0)
             return;
         if (!(Math.abs(expected-actual) <= delta))
             failNotEquals(message, new Double(expected), new Double(actual));
     }
     /**
      * Asserts that two doubles are equal concerning a delta. If the expected
      * value is infinity then the delta value is ignored.
      */
     static public void assertEquals(double expected, double actual, double delta) {
         assertEquals(null, expected, actual, delta);
     }
     /**
      * Asserts that two floats are equal concerning a positive delta. If they
      * are not an AssertionFailedError is thrown with the given message. If the
      * expected value is infinity then the delta value is ignored.
      */
     static public void assertEquals(String message, float expected, float actual, float delta) {
         if (Float.compare(expected, actual) == 0)
             return;
         if (!(Math.abs(expected - actual) <= delta))
                 failNotEquals(message, new Float(expected), new Float(actual));
     }
     /**
      * Asserts that two floats are equal concerning a delta. If the expected
      * value is infinity then the delta value is ignored.
      */
     static public void assertEquals(float expected, float actual, float delta) {
         assertEquals(null, expected, actual, delta);
     }
     /**
      * Asserts that two longs are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertEquals(String message, long expected, long actual) {
         assertEquals(message, new Long(expected), new Long(actual));
     }
     /**
      * Asserts that two longs are equal.
      */
     static public void assertEquals(long expected, long actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two booleans are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertEquals(String message, boolean expected, boolean actual) {
             assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
       }
     /**
      * Asserts that two booleans are equal.
       */
     static public void assertEquals(boolean expected, boolean actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two bytes are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
       static public void assertEquals(String message, byte expected, byte actual) {
         assertEquals(message, new Byte(expected), new Byte(actual));
     }
     /**
         * Asserts that two bytes are equal.
      */
     static public void assertEquals(byte expected, byte actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two chars are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
       static public void assertEquals(String message, char expected, char actual) {
             assertEquals(message, new Character(expected), new Character(actual));
       }
     /**
      * Asserts that two chars are equal.
      */
       static public void assertEquals(char expected, char actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two shorts are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertEquals(String message, short expected, short actual) {
             assertEquals(message, new Short(expected), new Short(actual));
     }
       /**
      * Asserts that two shorts are equal.
      */
     static public void assertEquals(short expected, short actual) {
         assertEquals(null, expected, actual);
     }
     /**
      * Asserts that two ints are equal. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
       static public void assertEquals(String message, int expected, int actual) {
         assertEquals(message, new Integer(expected), new Integer(actual));
       }
       /**
         * Asserts that two ints are equal.
      */
       static public void assertEquals(int expected, int actual) {
           assertEquals(null, expected, actual);
     }
     /**
      * Asserts that an object isn't null.
      */
     static public void assertNotNull(Object object) {
         assertNotNull(null, object);
     }
     /**
      * Asserts that an object isn't null. If it is
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertNotNull(String message, Object object) {
         assertTrue(message, object != null);
     }
     /**
      * Asserts that an object is null. If it isn't an {@link AssertionError} is
      * thrown.
      * Message contains: Expected: <null> but was: object
      *
      * @param object
      *            Object to check or <code>null</code>
      */
     static public void assertNull(Object object) {
         String message = "Expected: <null> but was: " + String.valueOf(object);
         assertNull(message, object);
     }
     /**
      * Asserts that an object is null.  If it is not
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertNull(String message, Object object) {
         assertTrue(message, object == null);
     }
     /**
      * Asserts that two objects refer to the same object. If they are not
      * an AssertionFailedError is thrown with the given message.
      */
     static public void assertSame(String message, Object expected, Object actual) {
         if (expected == actual)
             return;
         failNotSame(message, expected, actual);
     }
     /**
      * Asserts that two objects refer to the same object. If they are not
      * the same an AssertionFailedError is thrown.
      */
     static public void assertSame(Object expected, Object actual) {
         assertSame(null, expected, actual);
     }
     /**
      * Asserts that two objects do not refer to the same object. If they do
      * refer to the same object an AssertionFailedError is thrown with the
      * given message.
      */
     static public void assertNotSame(String message, Object expected, Object actual) {
         if (expected == actual)
             failSame(message);
     }
     /**
      * Asserts that two objects do not refer to the same object. If they do
      * refer to the same object an AssertionFailedError is thrown.
      */
     static public void assertNotSame(Object expected, Object actual) {
         assertNotSame(null, expected, actual);
     }

     static public void failSame(String message) {
         String formatted= "";
          if (message != null)
              formatted= message+" ";
          fail(formatted+"expected not same");
     }

     static public void failNotSame(String message, Object expected, Object actual) {
         String formatted= "";
         if (message != null)
             formatted= message+" ";
         fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
     }

     static public void failNotEquals(String message, Object expected, Object actual) {
         fail(format(message, expected, actual));
     }

     public static String format(String message, Object expected, Object actual) {
         String formatted= "";
         if (message != null && message.length() > 0)
             formatted= message+" ";
         return formatted+"expected:<"+expected+"> but was:<"+actual+">";
     }
 }

1.assertTrue(boolean condition)   用于判断一个条件为真，如果为false会抛出异常

2.assertFalse(boolean condition)   用于判断一个条件为假，如果为真会抛出异常。

3.assertEquals(..........)   用于判断前后相等。

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />