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		if (message == null) {
48			throw new AssertionFailedError();
49		}
50		throw new AssertionFailedError(message);
51	}
52	/**
53	 * Fails a test with no message.
54	 */
55	static public void fail() {
56		fail(null);
57	}
58	/**
59	 * Asserts that two objects are equal. If they are not
60	 * an AssertionFailedError is thrown with the given message.
61	 */
62	static public void assertEquals(String message, Object expected, Object actual) {
63		if (expected == null && actual == null)
64			return;
65		if (expected != null && expected.equals(actual))
66			return;
67		failNotEquals(message, expected, actual);
68	}
69	/**
70	 * Asserts that two objects are equal. If they are not
71	 * an AssertionFailedError is thrown.
72	 */
73	static public void assertEquals(Object expected, Object actual) {
74	    assertEquals(null, expected, actual);
75	}
76	/**
77	 * Asserts that two Strings are equal.
78	 */
79	static public void assertEquals(String message, String expected, String actual) {
80		if (expected == null && actual == null)
81			return;
82		if (expected != null && expected.equals(actual))
83			return;
84		String cleanMessage= message == null ? "" : message;
85		throw new ComparisonFailure(cleanMessage, expected, actual);
86	}
87	/**
88	 * Asserts that two Strings are equal.
89	 */
90	static public void assertEquals(String expected, String actual) {
91	    assertEquals(null, expected, actual);
92	}
93	/**
94	 * Asserts that two doubles are equal concerning a delta.  If they are not
95	 * an AssertionFailedError is thrown with the given message.  If the expected
96	 * value is infinity then the delta value is ignored.
97	 */
98	static public void assertEquals(String message, double expected, double actual, double delta) {
99		if (Double.compare(expected, actual) == 0)
100			return;
101		if (!(Math.abs(expected-actual) <= delta))
102			failNotEquals(message, new Double(expected), new Double(actual));
103	}
104	/**
105	 * Asserts that two doubles are equal concerning a delta. If the expected
106	 * value is infinity then the delta value is ignored.
107	 */
108	static public void assertEquals(double expected, double actual, double delta) {
109	    assertEquals(null, expected, actual, delta);
110	}
111	/**
112	 * Asserts that two floats are equal concerning a positive delta. If they
113	 * are not an AssertionFailedError is thrown with the given message. If the
114	 * expected value is infinity then the delta value is ignored.
115	 */
116	static public void assertEquals(String message, float expected, float actual, float delta) {
117		if (Float.compare(expected, actual) == 0)
118			return;
119		if (!(Math.abs(expected - actual) <= delta))
120				failNotEquals(message, new Float(expected), new Float(actual));
121	}
122	/**
123	 * Asserts that two floats are equal concerning a delta. If the expected
124	 * value is infinity then the delta value is ignored.
125	 */
126	static public void assertEquals(float expected, float actual, float delta) {
127		assertEquals(null, expected, actual, delta);
128	}
129	/**
130	 * Asserts that two longs are equal. If they are not
131	 * an AssertionFailedError is thrown with the given message.
132	 */
133	static public void assertEquals(String message, long expected, long actual) {
134	    assertEquals(message, new Long(expected), new Long(actual));
135	}
136	/**
137	 * Asserts that two longs are equal.
138	 */
139	static public void assertEquals(long expected, long actual) {
140	    assertEquals(null, expected, actual);
141	}
142	/**
143	 * Asserts that two booleans are equal. If they are not
144	 * an AssertionFailedError is thrown with the given message.
145	 */
146	static public void assertEquals(String message, boolean expected, boolean actual) {
147    		assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
148  	}
149	/**
150	 * Asserts that two booleans are equal.
151 	 */
152	static public void assertEquals(boolean expected, boolean actual) {
153		assertEquals(null, expected, actual);
154	}
155	/**
156	 * Asserts that two bytes are equal. If they are not
157	 * an AssertionFailedError is thrown with the given message.
158	 */
159  	static public void assertEquals(String message, byte expected, byte actual) {
160		assertEquals(message, new Byte(expected), new Byte(actual));
161	}
162	/**
163   	 * Asserts that two bytes are equal.
164	 */
165	static public void assertEquals(byte expected, byte actual) {
166		assertEquals(null, expected, actual);
167	}
168	/**
169	 * Asserts that two chars are equal. If they are not
170	 * an AssertionFailedError is thrown with the given message.
171	 */
172  	static public void assertEquals(String message, char expected, char actual) {
173    		assertEquals(message, new Character(expected), new Character(actual));
174  	}
175	/**
176	 * Asserts that two chars are equal.
177	 */
178  	static public void assertEquals(char expected, char actual) {
179		assertEquals(null, expected, actual);
180	}
181	/**
182	 * Asserts that two shorts are equal. If they are not
183	 * an AssertionFailedError is thrown with the given message.
184	 */
185	static public void assertEquals(String message, short expected, short actual) {
186    		assertEquals(message, new Short(expected), new Short(actual));
187	}
188  	/**
189	 * Asserts that two shorts are equal.
190	 */
191	static public void assertEquals(short expected, short actual) {
192		assertEquals(null, expected, actual);
193	}
194	/**
195	 * Asserts that two ints are equal. If they are not
196	 * an AssertionFailedError is thrown with the given message.
197	 */
198  	static public void assertEquals(String message, int expected, int actual) {
199		assertEquals(message, new Integer(expected), new Integer(actual));
200  	}
201  	/**
202   	 * Asserts that two ints are equal.
203	 */
204  	static public void assertEquals(int expected, int actual) {
205  		assertEquals(null, expected, actual);
206	}
207	/**
208	 * Asserts that an object isn't null.
209	 */
210	static public void assertNotNull(Object object) {
211		assertNotNull(null, object);
212	}
213	/**
214	 * Asserts that an object isn't null. If it is
215	 * an AssertionFailedError is thrown with the given message.
216	 */
217	static public void assertNotNull(String message, Object object) {
218		assertTrue(message, object != null);
219	}
220	/**
221	 * Asserts that an object is null. If it isn't an {@link AssertionError} is
222	 * thrown.
223	 * Message contains: Expected: <null> but was: object
224	 *
225	 * @param object
226	 *            Object to check or <code>null</code>
227	 */
228	static public void assertNull(Object object) {
229		String message = "Expected: <null> but was: " + String.valueOf(object);
230		assertNull(message, object);
231	}
232	/**
233	 * Asserts that an object is null.  If it is not
234	 * an AssertionFailedError is thrown with the given message.
235	 */
236	static public void assertNull(String message, Object object) {
237		assertTrue(message, object == null);
238	}
239	/**
240	 * Asserts that two objects refer to the same object. If they are not
241	 * an AssertionFailedError is thrown with the given message.
242	 */
243	static public void assertSame(String message, Object expected, Object actual) {
244		if (expected == actual)
245			return;
246		failNotSame(message, expected, actual);
247	}
248	/**
249	 * Asserts that two objects refer to the same object. If they are not
250	 * the same an AssertionFailedError is thrown.
251	 */
252	static public void assertSame(Object expected, Object actual) {
253	    assertSame(null, expected, actual);
254	}
255	/**
256	 * Asserts that two objects do not refer to the same object. If they do
257	 * refer to the same object an AssertionFailedError is thrown with the
258	 * given message.
259	 */
260	static public void assertNotSame(String message, Object expected, Object actual) {
261		if (expected == actual)
262			failSame(message);
263	}
264	/**
265	 * Asserts that two objects do not refer to the same object. If they do
266	 * refer to the same object an AssertionFailedError is thrown.
267	 */
268	static public void assertNotSame(Object expected, Object actual) {
269		assertNotSame(null, expected, actual);
270	}
271
272	static public void failSame(String message) {
273		String formatted= "";
274 		if (message != null)
275 			formatted= message+" ";
276 		fail(formatted+"expected not same");
277	}
278
279	static public void failNotSame(String message, Object expected, Object actual) {
280		String formatted= "";
281		if (message != null)
282			formatted= message+" ";
283		fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
284	}
285
286	static public void failNotEquals(String message, Object expected, Object actual) {
287		fail(format(message, expected, actual));
288	}
289
290	public static String format(String message, Object expected, Object actual) {
291		String formatted= "";
292		if (message != null && message.length() > 0)
293			formatted= message+" ";
294		return formatted+"expected:<"+expected+"> but was:<"+actual+">";
295	}
296}
297