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