assert.java

MoMEUnit是一个单元测试的J2ME的应用程序xUnit架构实例。这是来自JUnit框架

package momeunit.framework;

/**
 * A collection of static assert methods. A TestCase base class. If assertion
 * fails {@link AssertionFailedError} with descriptive message is thrown.
 * 
 * <p>
 * <strong>Note</strong> In this package there is no
 * <code>ComparisonFailure</code> class. The processing of compared strings
 * contained in this class is optimized and moved to the respective assert
 * methods.
 * </p>
 * 
 * @author Sergio Morozov
 * @version 1.1.2
 */
public class Assert
{
  /**
   * Protect constructor since it is a static only class
   * 
   * @since 1.0
   */
  protected Assert()
  {}

  /**
   * Asserts that a given condition is true. If it isn't throws an
   * AssertionFailedError with the given message.
   * 
   * @param message
   *          descriptive message of failure.
   * @param condition
   *          condition to check.
   * @since 1.0
   */
  static public void assertTrue(String message, boolean condition)
  {
    if (!condition) fail(message);
  }

  /**
   * Asserts that a given condition is true. If it isn't throws an
   * AssertionFailedError.
   * 
   * @param condition
   *          condition to check.
   * @since 1.0
   */
  static public void assertTrue(boolean condition)
  {
    assertTrue(null, condition);
  }

  /**
   * Asserts that a given condition is false. If it isn't throws an
   * AssertionFailedError with the given message.
   * 
   * @param message
   *          descriptive message of failure.
   * @param condition
   *          condition to check.
   * @since 1.0
   */
  static public void assertFalse(String message, boolean condition)
  {
    assertTrue(message, !condition);
  }

  /**
   * Asserts that a given condition is false. If it isn't throws an
   * AssertionFailedError.
   * 
   * @param condition
   *          condition to check.
   * @since 1.0
   */
  static public void assertFalse(boolean condition)
  {
    assertFalse(null, condition);
  }

  /**
   * Fails a test with a given message.
   * 
   * @param message
   *          descriptive message of failure.
   * @since 1.0
   */
  static public void fail(String message)
  {
    throw new AssertionFailedError(message);
  }

  /**
   * Fails a test with no message.
   * 
   * @since 1.0
   */
  static public void fail()
  {
    fail(null);
  }

  /**
   * Asserts that two objects are equal. If they are not throws an
   * AssertionFailedError with given message.
   * 
   * @param message
   *          descriptive message of failure.
   * @param expected
   *          expected object to be tested.
   * @param actual
   *          actual object to be tested.
   * @since 1.0
   */
  static public void assertEquals(String message, Object expected, Object actual)
  {
    if ((expected != null && !expected.equals(actual))
        || (actual != null && !actual.equals(expected))) failNotEquals(message,
        expected, actual);
  }

  /**
   * Asserts that two objects are equal. If they are not throws an
   * AssertionFailedError.
   * 
   * @param expected
   *          expected object to be tested.
   * @param actual
   *          actual object to be tested.
   * @since 1.0
   */
  static public void assertEquals(Object expected, Object actual)
  {
    assertEquals(null, expected, actual);
  }

  /**
   * Asserts that two Strings are equal. If they are not throws an
   * AssertionFailedError with given message and arguments. Compared strings are
   * processed so, that just different parts of them are visible with respective
   * "..." suffixes and prefixes.
   * 
   * @param message
   *          descriptive message of failure.
   * @param expected
   *          expected String to be tested.
   * @param actual
   *          actual String to be tested.
   * @since 1.0
   */
  static public void assertEquals(String message, String expected, String actual)
  {
    if ((expected != null && !expected.equals(actual))
        || (actual != null && !actual.equals(expected)))
    {
      if (expected != null && actual != null)
      {
        int expectedLength = expected.length() - 1;
        int actualLength = actual.length() - 1;
        int i = 0;
        int j = expectedLength;
        int k = actualLength;
        for (; i <= Math.min(expectedLength, actualLength)
            && expected.charAt(i) == actual.charAt(i); i++);
        for (; k >= i && j >= i && expected.charAt(j) == actual.charAt(k); k--, j--);

        expected = expected.substring(i, j + 1);
        actual = actual.substring(i, k + 1);

        if (j < expectedLength) expected = expected + "...";
        if (k < actualLength) actual = actual + "...";
        if (i > 0)
        {
          expected = "..." + expected;
          actual = "..." + actual;
        }
      }
      failNotEquals(message, expected, actual);
    }
  }

  /**
   * Asserts that two Strings are equal. If they are not an AssertionFailedError
   * is thrown and arguments. Compared strings are processed so, that just
   * different parts of them are visible with respective "..." suffixes and
   * prefixes.
   * 
   * @param expected
   *          expected String to be tested.
   * @param actual
   *          actual String to be tested.
   * @since 1.0
   */
  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
   * throws an AssertionFailedError with the given message. If the expected
   * value is infinity then the delta value is ignored.
   * 
   * @param message
   *          descriptive message of failure.
   * @param expected
   *          expected double to be tested.
   * @param actual
   *          actual double to be tested.
   * @param delta
   *          precision of comparison.
   * @since 1.0
   */
  static public void assertEquals(String message, double expected,
      double actual, double delta)
  {
    if (Double.isInfinite(expected))
    {
      if (!(expected == actual)) failNotEquals(message, new Double(expected),
          new Double(actual));
    } else if (!(Math.abs(expected - actual) <= delta)) failNotEquals(message,
        new Double(expected), new Double(actual));
  }

  /**
   * Asserts that two doubles are equal concerning a delta. If they are not
   * throws an AssertionFailedError. If the expected value is infinity then the
   * delta value is ignored.
   * 
   * @param expected
   *          expected double to be tested.
   * @param actual
   *          actual double to be tested.
   * @param delta
   *          precision of comparison.
   * @since 1.0
   */
  static public void assertEquals(double expected, double actual, double delta)
  {
    assertEquals(null, expected, actual, delta);
  }

  /**
   * Asserts that two floats are equal concerning a delta. If they are not
   * throws an AssertionFailedError with the given message. If the expected
   * value is infinity then the delta value is ignored.
   * 
   * @param message
   *          descriptive message of failure.
   * @param expected
   *          expected float to be tested.
   * @param actual
   *          actual float to be tested.
   * @param delta
   *          precision of comparison.
   * @since 1.0
   */
  static public void assertEquals(String message, float expected, float actual,
      float delta)
  {
    if (Float.isInfinite(expected))
    {
      if (!(expected == actual)) failNotEquals(message, new Float(expected),
          new Float(actual));
    } else if (!(Math.abs(expected - actual) <= delta)) failNotEquals(message,
        new Float(expected), new Float(actual));
  }

  /**
   * Asserts that two floats are equal concerning a delta. If they are not
   * throws an AssertionFailedError. If the expected value is infinity then the
   * delta value is ignored.
   * 
   * @param expected
   *          float to be tested.
   * @param actual
   *          float to be tested.
   * @param delta
   *          precision of comparison.
   * @since 1.0
   */
  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 throws an
   * AssertionFailedError with the given message.
   * 
   * @param message
   *          descriptive message of failure.
   * @param expected
   *          long to be tested.
   * @param actual
   *          long to be tested.
   * @since 1.0
   */
  static public void assertEquals(String message, long expected, long actual)
  {
    assertEquals(message, new Long(expected), new Long(actual));
  }

  /**
   * Asserts that two longs are equal. If they are not throws an
   * AssertionFailedError.
   * 
   * @param expected
   *          long to be tested.
   * @param actual
   *          long to be tested.
   * @since 1.0
   */
  static public void assertEquals(long expected, long actual)
  {
    assertEquals(null, expected, actual);
  }

  /**
   * Asserts that two booleans are equal. If they are not throws an
   * AssertionFailedError with the given message.
   * 
   * @param message
   *          descriptive message of failure.
   * @param expected
   *          boolean to be tested.
   * @param actual
   *          boolean to be tested.
   * @since 1.0
   */
  static public void assertEquals(String message, boolean expected,
      boolean actual)
  {
    assertEquals(message, new Boolean(expected), new Boolean(actual));
  }

  /**