1 package junit.framework; 2 3 /** 4 * A set of assert methods. Messages are only displayed when an assert fails. 5 * 6 * @deprecated Please use {@link org.junit.Assert} instead. 7 */ 8 @Deprecated 9 public class Assert { 10 /** 11 * Protect constructor since it is a static only class 12 */ 13 protected Assert() { 14 } 15 16 /** 17 * Asserts that a condition is true. If it isn't it throws 18 * an AssertionFailedError with the given message. 19 */ 20 static public void assertTrue(String message, boolean condition) { 21 if (!condition) { 22 fail(message); 23 } 24 } 25 26 /** 27 * Asserts that a condition is true. If it isn't it throws 28 * an AssertionFailedError. 29 */ 30 static public void assertTrue(boolean condition) { 31 assertTrue(null, condition); 32 } 33 34 /** 35 * Asserts that a condition is false. If it isn't it throws 36 * an AssertionFailedError with the given message. 37 */ 38 static public void assertFalse(String message, boolean condition) { 39 assertTrue(message, !condition); 40 } 41 42 /** 43 * Asserts that a condition is false. If it isn't it throws 44 * an AssertionFailedError. 45 */ 46 static public void assertFalse(boolean condition) { 47 assertFalse(null, condition); 48 } 49 50 /** 51 * Fails a test with the given message. 52 */ 53 static public void fail(String message) { 54 if (message == null) { 55 throw new AssertionFailedError(); 56 } 57 throw new AssertionFailedError(message); 58 } 59 60 /** 61 * Fails a test with no message. 62 */ 63 static public void fail() { 64 fail(null); 65 } 66 67 /** 68 * Asserts that two objects are equal. If they are not 69 * an AssertionFailedError is thrown with the given message. 70 */ 71 static public void assertEquals(String message, Object expected, Object actual) { 72 if (expected == null && actual == null) { 73 return; 74 } 75 if (expected != null && expected.equals(actual)) { 76 return; 77 } 78 failNotEquals(message, expected, actual); 79 } 80 81 /** 82 * Asserts that two objects are equal. If they are not 83 * an AssertionFailedError is thrown. 84 */ 85 static public void assertEquals(Object expected, Object actual) { 86 assertEquals(null, expected, actual); 87 } 88 89 /** 90 * Asserts that two Strings are equal. 91 */ 92 static public void assertEquals(String message, String expected, String actual) { 93 if (expected == null && actual == null) { 94 return; 95 } 96 if (expected != null && expected.equals(actual)) { 97 return; 98 } 99 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, new Double(expected), new Double(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, new Float(expected), new Float(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 } 340
