1 package junit.framework;

     2 

     3 /**

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

     5  */

     6 

     7 public class Assert {

     8 	/**

     9 	 * Protect constructor since it is a static only class

    10 	 */

    11 	protected Assert() {

    12 	}

    13 

    14 	/**

    15 	 * Asserts that a condition is true. If it isn't it throws

    16 	 * an AssertionFailedError with the given message.

    17 	 */

    18 	static public void assertTrue(String message, boolean condition) {

    19 		if (!condition)

    20 			fail(message);

    21 	}

    22 	/**

    23 	 * Asserts that a condition is true. If it isn't it throws

    24 	 * an AssertionFailedError.

    25 	 */

    26 	static public void assertTrue(boolean condition) {

    27 		assertTrue(null, condition);

    28 	}

    29 	/**

    30 	 * Asserts that a condition is false. If it isn't it throws

    31 	 * an AssertionFailedError with the given message.

    32 	 */

    33 	static public void assertFalse(String message, boolean condition) {

    34 		assertTrue(message, !condition);

    35 	}

    36 	/**

    37 	 * Asserts that a condition is false. If it isn't it throws

    38 	 * an AssertionFailedError.

    39 	 */

    40 	static public void assertFalse(boolean condition) {

    41 		assertFalse(null, condition);

    42 	}

    43 	/**

    44 	 * Fails a test with the given message.

    45 	 */

    46 	static public void fail(String message) {

    47 		throw new AssertionFailedError(message);

    48 	}

    49 	/**

    50 	 * Fails a test with no message.

    51 	 */

    52 	static public void fail() {

    53 		fail(null);

    54 	}

    55 	/**

    56 	 * Asserts that two objects are equal. If they are not

    57 	 * an AssertionFailedError is thrown with the given message.

    58 	 */

    59 	static public void assertEquals(String message, Object expected, Object actual) {

    60 		if (expected == null && actual == null)

    61 			return;

    62 		if (expected != null && expected.equals(actual))

    63 			return;

    64 		failNotEquals(message, expected, actual);

    65 	}

    66 	/**

    67 	 * Asserts that two objects are equal. If they are not

    68 	 * an AssertionFailedError is thrown.

    69 	 */

    70 	static public void assertEquals(Object expected, Object actual) {

    71 	    assertEquals(null, expected, actual);

    72 	}

    73 	/**

    74 	 * Asserts that two Strings are equal. 

    75 	 */

    76 	static public void assertEquals(String message, String expected, String actual) {

    77 		if (expected == null && actual == null)

    78 			return;

    79 		if (expected != null && expected.equals(actual))

    80 			return;

    81 		throw new ComparisonFailure(message, expected, actual);

    82 	}

    83 	/**

    84 	 * Asserts that two Strings are equal. 

    85 	 */

    86 	static public void assertEquals(String expected, String actual) {

    87 	    assertEquals(null, expected, actual);

    88 	}

    89 	/**

    90 	 * Asserts that two doubles are equal concerning a delta.  If they are not

    91 	 * an AssertionFailedError is thrown with the given message.  If the expected

    92 	 * value is infinity then the delta value is ignored.

    93 	 */

    94 	static public void assertEquals(String message, double expected, double actual, double delta) {

    95 		if (Double.compare(expected, actual) == 0)

    96 			return;

    97 		if (!(Math.abs(expected-actual) <= delta))

    98 			failNotEquals(message, new Double(expected), new Double(actual));

    99 	}

   100 	/**

   101 	 * Asserts that two doubles are equal concerning a delta. If the expected

   102 	 * value is infinity then the delta value is ignored.

   103 	 */

   104 	static public void assertEquals(double expected, double actual, double delta) {

   105 	    assertEquals(null, expected, actual, delta);

   106 	}

   107 	/**

   108 	 * Asserts that two floats are equal concerning a positive delta. If they

   109 	 * are not an AssertionFailedError is thrown with the given message. If the

   110 	 * expected value is infinity then the delta value is ignored.

   111 	 */

   112 	static public void assertEquals(String message, float expected, float actual, float delta) {

   113 		if (Float.compare(expected, actual) == 0)

   114 			return;

   115 		if (!(Math.abs(expected - actual) <= delta))

   116 				failNotEquals(message, new Float(expected), new Float(actual));

   117 	}

   118 	/**

   119 	 * Asserts that two floats are equal concerning a delta. If the expected

   120 	 * value is infinity then the delta value is ignored.

   121 	 */

   122 	static public void assertEquals(float expected, float actual, float delta) {

   123 		assertEquals(null, expected, actual, delta);

   124 	}

   125 	/**

   126 	 * Asserts that two longs are equal. If they are not

   127 	 * an AssertionFailedError is thrown with the given message.

   128 	 */

   129 	static public void assertEquals(String message, long expected, long actual) {

   130 	    assertEquals(message, new Long(expected), new Long(actual));

   131 	}

   132 	/**

   133 	 * Asserts that two longs are equal.

   134 	 */

   135 	static public void assertEquals(long expected, long actual) {

   136 	    assertEquals(null, expected, actual);

   137 	}

   138 	/**

   139 	 * Asserts that two booleans are equal. If they are not

   140 	 * an AssertionFailedError is thrown with the given message.

   141 	 */

   142 	static public void assertEquals(String message, boolean expected, boolean actual) {

   143     		assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));

   144   	}

   145 	/**

   146 	 * Asserts that two booleans are equal.

   147  	 */

   148 	static public void assertEquals(boolean expected, boolean actual) {

   149 		assertEquals(null, expected, actual);

   150 	}

   151 	/**

   152 	 * Asserts that two bytes are equal. If they are not

   153 	 * an AssertionFailedError is thrown with the given message.

   154 	 */

   155   	static public void assertEquals(String message, byte expected, byte actual) {

   156 		assertEquals(message, new Byte(expected), new Byte(actual));

   157 	}

   158 	/**

   159    	 * Asserts that two bytes are equal.

   160 	 */

   161 	static public void assertEquals(byte expected, byte actual) {

   162 		assertEquals(null, expected, actual);

   163 	}

   164 	/**

   165 	 * Asserts that two chars are equal. If they are not

   166 	 * an AssertionFailedError is thrown with the given message.

   167 	 */

   168   	static public void assertEquals(String message, char expected, char actual) {

   169     		assertEquals(message, new Character(expected), new Character(actual));

   170   	}

   171 	/**

   172 	 * Asserts that two chars are equal.

   173 	 */

   174   	static public void assertEquals(char expected, char actual) {

   175 		assertEquals(null, expected, actual);

   176 	}

   177 	/**

   178 	 * Asserts that two shorts are equal. If they are not

   179 	 * an AssertionFailedError is thrown with the given message.

   180 	 */

   181 	static public void assertEquals(String message, short expected, short actual) {

   182     		assertEquals(message, new Short(expected), new Short(actual));

   183 	}

   184   	/**

   185 	 * Asserts that two shorts are equal.

   186 	 */

   187 	static public void assertEquals(short expected, short actual) {

   188 		assertEquals(null, expected, actual);

   189 	}

   190 	/**

   191 	 * Asserts that two ints are equal. If they are not

   192 	 * an AssertionFailedError is thrown with the given message.

   193 	 */

   194   	static public void assertEquals(String message, int expected, int actual) {

   195 		assertEquals(message, new Integer(expected), new Integer(actual));

   196   	}

   197   	/**

   198    	 * Asserts that two ints are equal.

   199 	 */

   200   	static public void assertEquals(int expected, int actual) {

   201   		assertEquals(null, expected, actual);

   202 	}

   203 	/**

   204 	 * Asserts that an object isn't null.

   205 	 */

   206 	static public void assertNotNull(Object object) {

   207 		assertNotNull(null, object);

   208 	}

   209 	/**

   210 	 * Asserts that an object isn't null. If it is

   211 	 * an AssertionFailedError is thrown with the given message.

   212 	 */

   213 	static public void assertNotNull(String message, Object object) {

   214 		assertTrue(message, object != null);

   215 	}

   216 	/**

   217 	 * Asserts that an object is null.

   218 	 */

   219 	static public void assertNull(Object object) {

   220 		assertNull(null, object);

   221 	}

   222 	/**

   223 	 * Asserts that an object is null.  If it is not

   224 	 * an AssertionFailedError is thrown with the given message.

   225 	 */

   226 	static public void assertNull(String message, Object object) {

   227 		assertTrue(message, object == null);

   228 	}

   229 	/**

   230 	 * Asserts that two objects refer to the same object. If they are not

   231 	 * an AssertionFailedError is thrown with the given message.

   232 	 */

   233 	static public void assertSame(String message, Object expected, Object actual) {

   234 		if (expected == actual)

   235 			return;

   236 		failNotSame(message, expected, actual);

   237 	}

   238 	/**

   239 	 * Asserts that two objects refer to the same object. If they are not

   240 	 * the same an AssertionFailedError is thrown.

   241 	 */

   242 	static public void assertSame(Object expected, Object actual) {

   243 	    assertSame(null, expected, actual);

   244 	}

   245 	/**

   246 	 * Asserts that two objects do not refer to the same object. If they do

   247 	 * refer to the same object an AssertionFailedError is thrown with the

   248 	 * given message.

   249 	 */

   250 	static public void assertNotSame(String message, Object expected, Object actual) {

   251 		if (expected == actual)

   252 			failSame(message);

   253 	}

   254 	/**

   255 	 * Asserts that two objects do not refer to the same object. If they do

   256 	 * refer to the same object an AssertionFailedError is thrown.

   257 	 */

   258 	static public void assertNotSame(Object expected, Object actual) {

   259 		assertNotSame(null, expected, actual);

   260 	}

   261 

   262 	static public void failSame(String message) {

   263 		String formatted= "";

   264  		if (message != null)

   265  			formatted= message+" ";

   266  		fail(formatted+"expected not same");

   267 	}

   268 

   269 	static public void failNotSame(String message, Object expected, Object actual) {

   270 		String formatted= "";

   271 		if (message != null)

   272 			formatted= message+" ";

   273 		fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");

   274 	}

   275 

   276 	static public void failNotEquals(String message, Object expected, Object actual) {

   277 		fail(format(message, expected, actual));

   278 	}

   279 

   280 	public static String format(String message, Object expected, Object actual) {

   281 		String formatted= "";

   282 		if (message != null)

   283 			formatted= message+" ";

   284 		return formatted+"expected:<"+expected+"> but was:<"+actual+">";

   285 	}

   286 }