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 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 }
1.assertTrue(boolean condition) 用于判断一个条件为真，如果为false会抛出异常
2.assertFalse(boolean condition) 用于判断一个条件为假，如果为真会抛出异常。
3.assertEquals(..........) 用于判断前后相等。
时间： 2024-11-07 23:54:04