1 /*
2 * The JUnit-addons Software License, Version 1.0
3 * (based on the Apache Software License, Version 1.1)
4 *
5 * Copyright (c) 2002-2003 Vladimir R. Bossicard. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * 3. The end-user documentation included with the redistribution, if
20 * any, must include the following acknowlegement:
21 * "This product includes software developed by Vladimir R.
22 * Bossicard as well as other contributors
23 * (http://junit-addons.sourceforge.net/)."
24 * Alternately, this acknowlegement may appear in the software itself,
25 * if and wherever such third-party acknowlegements normally appear.
26 *
27 * 4. The names "JUnit-addons" must not be used to endorse or promote
28 * products derived from this software without prior written
29 * permission. For written permission, please contact
30 * vbossica@users.sourceforge.net.
31 *
32 * 5. Products derived from this software may not be called "JUnit-addons"
33 * nor may "JUnit-addons" appear in their names without prior written
34 * permission of the project managers.
35 *
36 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47 * SUCH DAMAGE.
48 * ======================================================================
49 *
50 * This software consists of voluntary contributions made by many
51 * individuals. For more information on the JUnit-addons Project, please
52 * see <http://junit-addons.sourceforge.net/>.
53 */
54
55 package junitx.framework;
56
57 import junit.framework.Assert;
58
59 import java.util.ArrayList;
60 import java.util.Arrays;
61
62 /**
63 * A set of assert methods specially targetted to asserting arrays.
64 *
65 * @version $Revision: 1.11 $ $Date: 2003/04/14 01:06:32 $
66 * @author <a href="mailto:vbossica@users.sourceforge.net">Vladimir R. Bossicard</a>
67 */
68 public class ArrayAssert {
69
70 /**
71 * Don't let anyone have access to this constructor.
72 */
73 private ArrayAssert() {
74 }
75
76 /**
77 * Asserts that two arrays are equal. Throws an
78 * <tt>AssertionFailedError</tt> if they are not.
79 *
80 * Two arrays are considered equals if:
81 * <ul>
82 * <li>their respective lengths are the same</li>
83 * <li>the respective messages must be equal</li>
84 * <li>the respective localized messages must be equal</li>
85 * </ul>
86 */
87 static public void assertEquals(String message,
88 Object[] expected,
89 Object[] actual) {
90 if (Arrays.equals(expected, actual)) {
91 return;
92 }
93
94 String formatted = "";
95 if (message != null) {
96 formatted = message + " ";
97 }
98
99 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
100 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
101 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
102 for (int i = 0; i < expected.length; i++) {
103 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
104 }
105 }
106
107 /**
108 * Asserts that two arrays are equal. Throws an
109 * <tt>AssertionFailedError</tt> if they are not.
110 */
111 static public void assertEquals(Object[] expected,
112 Object[] actual) {
113 assertEquals(null, expected, actual);
114 }
115
116 /**
117 * Asserts that two arrays are equal. Two arrays are considered equal if:
118 * <ul>
119 * <li>their respective lengths are the same</i>
120 * <li>all corresponding pairs of elements are equal (within the delta range)
121 * <li>both array references are <code>null</code>
122 * </ul>
123 *
124 * @param expected a double array of expected values
125 * @param actual a double array of actual values
126 * @param delta tolerated delta
127 */
128 public static void assertEquals(double[] expected,
129 double[] actual,
130 double delta) {
131 assertEquals(null, expected, actual, delta);
132 }
133
134 /**
135 * Asserts that two arrays are equal. Two arrays are considered equal if:
136 * <ul>
137 * <li>their respective lengths are the same</i>
138 * <li>all corresponding pairs of elements are equal (within the delta range)
139 * <li>both array references are <code>null</code>
140 * </ul>
141 *
142 * @param message message to display when arrays are not equal
143 * @param expected a double array of expected values
144 * @param actual a double array of actual values
145 * @param delta tolerated delta
146 */
147 public static void assertEquals(String message,
148 double[] expected,
149 double[] actual,
150 double delta) {
151 if (Arrays.equals(expected, actual)) {
152 return;
153 }
154
155 String formatted = "";
156 if (message != null) {
157 formatted = message + " ";
158 }
159
160 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
161 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
162 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
163 for (int i = 0; i < actual.length; i++) {
164 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i], delta);
165 }
166 }
167
168 /**
169 * Asserts that two arrays are equal. Two arrays are considered equal if:
170 * <ul>
171 * <li>their respective lengths are the same</i>
172 * <li>all corresponding pairs of elements are equal (within the delta range)
173 * <li>both array references are <code>null</code>
174 * </ul>
175 *
176 * @param message message to display when arrays are not equal
177 * @param expected a float array of expected values
178 * @param actual a float array of actual values
179 * @param delta tolerated delta
180 */
181 public static void assertEquals(String message,
182 float[] expected,
183 float[] actual,
184 float delta) {
185 if (Arrays.equals(expected, actual)) {
186 return;
187 }
188
189 String formatted = "";
190 if (message != null) {
191 formatted = message + " ";
192 }
193
194 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
195 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
196 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
197 for (int i = 0; i < actual.length; i++) {
198 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i], delta);
199 }
200 }
201
202 /**
203 * Asserts that two arrays are equal. Two arrays are considered equal if:
204 * <ul>
205 * <li>their respective lengths are the same</i>
206 * <li>all corresponding pairs of elements are equal (within the delta range)
207 * <li>both array references are <code>null</code>
208 * </ul>
209 *
210 * @param expected a float array of expected values
211 * @param actual a float array of actual values
212 * @param delta tolerated delta
213 */
214 public static void assertEquals(float[] expected,
215 float[] actual,
216 float delta) {
217 assertEquals(null, expected, actual, delta);
218 }
219
220 /**
221 * Asserts that two arrays are equal. Two arrays are considered equal if:
222 * <ul>
223 * <li>their respective lengths are the same</i>
224 * <li>all corresponding pairs of elements are equal
225 * <li>both array references are <code>null</code>
226 * </ul>
227 *
228 * @param message message to display when arrays are not equal
229 * @param expected a long array of expected values
230 * @param actual a long array of actual values
231 */
232 public static void assertEquals(String message,
233 long[] expected,
234 long[] actual) {
235 if (Arrays.equals(expected, actual)) {
236 return;
237 }
238
239 String formatted = "";
240 if (message != null) {
241 formatted = message + " ";
242 }
243
244 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
245 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
246 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
247 for (int i = 0; i < actual.length; i++) {
248 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
249 }
250 }
251
252 /**
253 * Asserts that two arrays are equal. Two arrays are considered equal if:
254 * <ul>
255 * <li>their respective lengths are the same</i>
256 * <li>all corresponding pairs of elements are equal
257 * <li>both array references are <code>null</code>
258 * </ul>
259 *
260 * @param expected a long array of expected values
261 * @param actual a long array of actual values
262 */
263 public static void assertEquals(long[] expected,
264 long[] actual) {
265 assertEquals(null, expected, actual);
266 }
267
268 /**
269 * Asserts that two arrays are equal. Two arrays are considered equal if:
270 * <ul>
271 * <li>their respective lengths are the same</i>
272 * <li>all corresponding pairs of elements are equal
273 * <li>both array references are <code>null</code>
274 * </ul>
275 *
276 * @param message message to display when arrays are not equal
277 * @param expected an int array of expected values
278 * @param actual an int array of actual values
279 */
280 public static void assertEquals(String message,
281 int[] expected,
282 int[] actual) {
283 if (Arrays.equals(expected, actual)) {
284 return;
285 }
286
287 String formatted = "";
288 if (message != null) {
289 formatted = message + " ";
290 }
291
292 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
293 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
294 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
295
296 for (int i = 0; i < actual.length; i++) {
297 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
298 }
299 }
300
301 /**
302 * Asserts that two arrays are equal. Two arrays are considered equal if:
303 * <ul>
304 * <li>their respective lengths are the same</i>
305 * <li>all corresponding pairs of elements are equal
306 * <li>both array references are <code>null</code>
307 * </ul>
308 *
309 * @param expected an int array of expected values
310 * @param actual an int array of actual values
311 */
312 public static void assertEquals(int[] expected,
313 int[] actual) {
314 assertEquals(null, expected, actual);
315 }
316
317 /**
318 * Asserts that two arrays are equal. Two arrays are considered equal if:
319 * <ul>
320 * <li>their respective lengths are the same</i>
321 * <li>all corresponding pairs of elements are equal
322 * <li>both array references are <code>null</code>
323 * </ul>
324 *
325 * @param message message to display when arrays are not equal
326 * @param expected a short array of expected values
327 * @param actual a short array of actual values
328 */
329 public static void assertEquals(String message,
330 short[] expected,
331 short[] actual) {
332 if (Arrays.equals(expected, actual)) {
333 return;
334 }
335
336 String formatted = "";
337 if (message != null) {
338 formatted = message + " ";
339 }
340
341 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
342 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
343 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
344
345 for (int i = 0; i < actual.length; i++) {
346 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
347 }
348 }
349
350 /**
351 * Asserts that two arrays are equal. Two arrays are considered equal if:
352 * <ul>
353 * <li>their respective lengths are the same</i>
354 * <li>all corresponding pairs of elements are equal
355 * <li>both array references are <code>null</code>
356 * </ul>
357 *
358 * @param expected a short array of expected values
359 * @param actual a short array of actual values
360 */
361 public static void assertEquals(short[] expected,
362 short[] actual) {
363 assertEquals(null, expected, actual);
364 }
365
366 /**
367 * Asserts that two arrays are equal. Two arrays are considered equal if:
368 * <ul>
369 * <li>their respective lengths are the same</i>
370 * <li>all corresponding pairs of elements are equal
371 * <li>both array references are <code>null</code>
372 * </ul>
373 *
374 * @param message message to display when arrays are not equal
375 * @param expected a short array of expected values
376 * @param actual a short array of actual values
377 */
378 public static void assertEquals(String message,
379 char[] expected,
380 char[] actual) {
381 if (Arrays.equals(expected, actual)) {
382 return;
383 }
384
385 String formatted = "";
386 if (message != null) {
387 formatted = message + " ";
388 }
389
390 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
391 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
392 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
393 for (int i = 0; i < actual.length; i++) {
394 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
395 }
396 }
397
398 /**
399 * Asserts that two arrays are equal. Two arrays are considered equal if:
400 * <ul>
401 * <li>their respective lengths are the same</i>
402 * <li>all corresponding pairs of elements are equal
403 * <li>both array references are <code>null</code>
404 * </ul>
405 *
406 * @param expected a short array of expected values
407 * @param actual a short array of actual values
408 */
409 public static void assertEquals(char[] expected,
410 char[] actual) {
411 assertEquals(null, expected, actual);
412 }
413
414 /**
415 * Asserts that two arrays are equal. Two arrays are considered equal if:
416 * <ul>
417 * <li>their respective lengths are the same</i>
418 * <li>all corresponding pairs of elements are equal
419 * <li>both array references are <code>null</code>
420 * </ul>
421 *
422 * @param message message to display when arrays are not equal
423 * @param expected a short array of expected values
424 * @param actual a short array of actual values
425 */
426 public static void assertEquals(String message,
427 boolean[] expected,
428 boolean[] actual) {
429 if (Arrays.equals(expected, actual)) {
430 return;
431 }
432
433 String formatted = "";
434 if (message != null) {
435 formatted = message + " ";
436 }
437
438 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
439 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
440 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
441 for (int i = 0; i < actual.length; i++) {
442 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
443 }
444 }
445
446 /**
447 * Asserts that two arrays are equal. Two arrays are considered equal if:
448 * <ul>
449 * <li>their respective lengths are the same</i>
450 * <li>all corresponding pairs of elements are equal
451 * <li>both array references are <code>null</code>
452 * </ul>
453 *
454 * @param expected a short array of expected values
455 * @param actual a short array of actual values
456 */
457 public static void assertEquals(boolean[] expected,
458 boolean[] actual) {
459 assertEquals(null, expected, actual);
460 }
461
462 /**
463 * Asserts that two arrays are equal. Two arrays are considered equal if:
464 * <ul>
465 * <li>their respective lengths are the same</i>
466 * <li>all corresponding pairs of elements are equal
467 * <li>both array references are <code>null</code>
468 * </ul>
469 *
470 * @param message message to display when arrays are not equal
471 * @param expected a byte array of expected values
472 * @param actual a byte array of actual values
473 */
474 public static void assertEquals(String message,
475 byte[] expected,
476 byte[] actual) {
477 if (Arrays.equals(expected, actual)) {
478 return;
479 }
480
481 String formatted = "";
482 if (message != null) {
483 formatted = message + " ";
484 }
485
486 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
487 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
488 Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
489 for (int i = 0; i < actual.length; i++) {
490 Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
491 }
492 }
493
494 /**
495 * Asserts that two arrays are equal. Two arrays are considered equal if:
496 * <ul>
497 * <li>their respective lengths are the same</i>
498 * <li>all corresponding pairs of elements are equal
499 * <li>both array references are <code>null</code>
500 * </ul>
501 *
502 * @param expected a byte array of expected values
503 * @param actual a byte array of actual values
504 */
505 public static void assertEquals(byte[] expected,
506 byte[] actual) {
507 assertEquals(null, expected, actual);
508 }
509
510 /**
511 * Asserts that two arrays have the same elements, but not necessarily in
512 * the same order. If order is important then use assertEquals(). If a
513 * difference is found, the object is listed by calling its toString() method.
514 * Arrays are equal if both are <i>null</i>.
515 *
516 * Equality of objects uses the equals method.
517 *
518 * @see #assertEquals(String message, Object[] expected, Object[] actual)
519 *
520 * @param message message to display when arrays are not equal
521 * @param expected an Object array of expected values
522 * @param actual an Object array of actual values
523 */
524 public static void assertEquivalenceArrays(String message,
525 Object[] expected,
526 Object[] actual) {
527 if (Arrays.equals(expected, actual)) {
528 return;
529 }
530
531 String formatted = "";
532 if (message != null) {
533 formatted = message + " ";
534 }
535
536 Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
537 Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
538
539 ArrayList missing = new ArrayList();
540 for (int i = 0; i < expected.length; i++) {
541 missing.add(expected[i]);
542 }
543
544 ArrayList extra = new ArrayList();
545 for (int i = 0; i < actual.length; i++) {
546 extra.add(actual[i]);
547 }
548
549 ArrayList missingClone = (ArrayList) missing.clone();
550 missing.removeAll(extra);
551 extra.removeAll(missingClone);
552
553 Assert.assertTrue(formatted + "[Missing elements: " + missing + "]", missing.size() == 0);
554 Assert.assertTrue(formatted + "[Extra elements: " + extra + "]", extra.size() == 0);
555 }
556
557 /**
558 * Assertion that both arrays has the same elements, but not necessarily in
559 * the same order. If order is important then use assertEquals(). If a
560 * difference is found, the object is listed by calling its toString() method.
561 * Arrays are equal if both are <i>null</i>.
562 *
563 * Equality of objects uses the equals method.
564 *
565 * @see #assertEquals(String message, Object[] expected, Object[] actual)
566 *
567 * @param expected an Object array of expected values
568 * @param actual an Object array of actual values
569 */
570 public static void assertEquivalenceArrays(Object[] expected,
571 Object[] actual) {
572 assertEquivalenceArrays(null, expected, actual);
573 }
574
575 }