Assert.java revision 58a8b0aba2dec5695628a2bf25a3fae42c2c3533
1package junit.framework; 2 3/** 4 * A set of assert methods. Messages are only displayed when an assert fails. 5 */ 6 7public 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 delta. If they are not 109 * an AssertionFailedError is thrown with the given message. If the expected 110 * value is infinity then the delta value is ignored. 111 */ 112 static public void assertEquals(String message, float expected, float actual, float delta) { 113 // handle infinity specially since subtracting to infinite values gives NaN and the 114 // the following test fails 115 if (Float.isInfinite(expected)) { 116 if (!(expected == actual)) 117 failNotEquals(message, new Float(expected), new Float(actual)); 118 } else if (!(Math.abs(expected-actual) <= delta)) 119 failNotEquals(message, new Float(expected), new Float(actual)); 120 } 121 /** 122 * Asserts that two floats are equal concerning a delta. If the expected 123 * value is infinity then the delta value is ignored. 124 */ 125 static public void assertEquals(float expected, float actual, float delta) { 126 assertEquals(null, expected, actual, delta); 127 } 128 /** 129 * Asserts that two longs are equal. If they are not 130 * an AssertionFailedError is thrown with the given message. 131 */ 132 static public void assertEquals(String message, long expected, long actual) { 133 assertEquals(message, new Long(expected), new Long(actual)); 134 } 135 /** 136 * Asserts that two longs are equal. 137 */ 138 static public void assertEquals(long expected, long actual) { 139 assertEquals(null, expected, actual); 140 } 141 /** 142 * Asserts that two booleans are equal. If they are not 143 * an AssertionFailedError is thrown with the given message. 144 */ 145 static public void assertEquals(String message, boolean expected, boolean actual) { 146 assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual)); 147 } 148 /** 149 * Asserts that two booleans are equal. 150 */ 151 static public void assertEquals(boolean expected, boolean actual) { 152 assertEquals(null, expected, actual); 153 } 154 /** 155 * Asserts that two bytes are equal. If they are not 156 * an AssertionFailedError is thrown with the given message. 157 */ 158 static public void assertEquals(String message, byte expected, byte actual) { 159 assertEquals(message, new Byte(expected), new Byte(actual)); 160 } 161 /** 162 * Asserts that two bytes are equal. 163 */ 164 static public void assertEquals(byte expected, byte actual) { 165 assertEquals(null, expected, actual); 166 } 167 /** 168 * Asserts that two chars are equal. If they are not 169 * an AssertionFailedError is thrown with the given message. 170 */ 171 static public void assertEquals(String message, char expected, char actual) { 172 assertEquals(message, new Character(expected), new Character(actual)); 173 } 174 /** 175 * Asserts that two chars are equal. 176 */ 177 static public void assertEquals(char expected, char actual) { 178 assertEquals(null, expected, actual); 179 } 180 /** 181 * Asserts that two shorts are equal. If they are not 182 * an AssertionFailedError is thrown with the given message. 183 */ 184 static public void assertEquals(String message, short expected, short actual) { 185 assertEquals(message, new Short(expected), new Short(actual)); 186 } 187 /** 188 * Asserts that two shorts are equal. 189 */ 190 static public void assertEquals(short expected, short actual) { 191 assertEquals(null, expected, actual); 192 } 193 /** 194 * Asserts that two ints are equal. If they are not 195 * an AssertionFailedError is thrown with the given message. 196 */ 197 static public void assertEquals(String message, int expected, int actual) { 198 assertEquals(message, new Integer(expected), new Integer(actual)); 199 } 200 /** 201 * Asserts that two ints are equal. 202 */ 203 static public void assertEquals(int expected, int actual) { 204 assertEquals(null, expected, actual); 205 } 206 /** 207 * Asserts that an object isn't null. 208 */ 209 static public void assertNotNull(Object object) { 210 assertNotNull(null, object); 211 } 212 /** 213 * Asserts that an object isn't null. If it is 214 * an AssertionFailedError is thrown with the given message. 215 */ 216 static public void assertNotNull(String message, Object object) { 217 assertTrue(message, object != null); 218 } 219 /** 220 * Asserts that an object is null. 221 */ 222 static public void assertNull(Object object) { 223 assertNull(null, object); 224 } 225 /** 226 * Asserts that an object is null. If it is not 227 * an AssertionFailedError is thrown with the given message. 228 */ 229 static public void assertNull(String message, Object object) { 230 assertTrue(message, object == null); 231 } 232 /** 233 * Asserts that two objects refer to the same object. If they are not 234 * an AssertionFailedError is thrown with the given message. 235 */ 236 static public void assertSame(String message, Object expected, Object actual) { 237 if (expected == actual) 238 return; 239 failNotSame(message, expected, actual); 240 } 241 /** 242 * Asserts that two objects refer to the same object. If they are not 243 * the same an AssertionFailedError is thrown. 244 */ 245 static public void assertSame(Object expected, Object actual) { 246 assertSame(null, expected, actual); 247 } 248 /** 249 * Asserts that two objects do not refer to the same object. If they do 250 * refer to the same object an AssertionFailedError is thrown with the 251 * given message. 252 */ 253 static public void assertNotSame(String message, Object expected, Object actual) { 254 if (expected == actual) 255 failSame(message); 256 } 257 /** 258 * Asserts that two objects do not refer to the same object. If they do 259 * refer to the same object an AssertionFailedError is thrown. 260 */ 261 static public void assertNotSame(Object expected, Object actual) { 262 assertNotSame(null, expected, actual); 263 } 264 265 static public void failSame(String message) { 266 String formatted= ""; 267 if (message != null) 268 formatted= message+" "; 269 fail(formatted+"expected not same"); 270 } 271 272 static public void failNotSame(String message, Object expected, Object actual) { 273 String formatted= ""; 274 if (message != null) 275 formatted= message+" "; 276 fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">"); 277 } 278 279 static public void failNotEquals(String message, Object expected, Object actual) { 280 fail(format(message, expected, actual)); 281 } 282 283 static String format(String message, Object expected, Object actual) { 284 String formatted= ""; 285 if (message != null) 286 formatted= message+" "; 287 return formatted+"expected:<"+expected+"> but was:<"+actual+">"; 288 } 289} 290