Implemented the ObjectAdapter for adapting existing objects to a component.
[utils] / support / general / src / test / java / org / wamblee / test / AssertionUtils.java
1 /*
2  * Copyright 2006 the original author or authors.
3  * 
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * 
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  * 
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.wamblee.test;
17
18 import java.util.Arrays;
19 import java.util.Comparator;
20 import java.util.Iterator;
21 import java.util.List;
22 import java.util.Map;
23 import java.util.Set;
24
25 import junit.framework.TestCase;
26
27 /**
28  * Useful assertions for use in test cases.
29  *
30  * @author Erik Brakkee
31  */
32 public final class AssertionUtils {
33
34     /**
35      * Disabled constructor.
36      * 
37      */
38     private AssertionUtils() {
39         // Empty
40     }
41     
42     /**
43      * Asserts that two object arrays are equal.
44      * 
45      * @param aExpected
46      *            Expected object array.
47      * @param aActual
48      *            Actual object array.
49      */
50     public static <T> void assertEquals(T[] aExpected, T[] aActual) {
51         assertEquals("", aExpected, aActual);
52     }
53     
54
55     /**
56      * Asserts that two object arrays are equal.
57      * 
58      * @param aMsg
59      *            Message.
60      * @param aExpected
61      *            Expected array.
62      * @param aActual
63      *            Actual array.
64      */
65     public static <T> void assertEquals(String aMsg, T[] aExpected,
66             T[] aActual) {
67         TestCase.assertEquals(aMsg + ": Array lengths ", aExpected.length,
68                 aActual.length);
69
70         for (int i = 0; i < aExpected.length; i++) {
71             TestCase.assertEquals(aMsg + ": Element " + i, aExpected[i],
72                     aActual[i]);
73         }
74     }
75     
76
77     /**
78      * Asserts that two objects are equal, and in case the object is an Object[]
79      * delegates to {@link #assertEquals(String, Object[], Object[]).
80      * 
81      * @param aMsg
82      *            Message.
83      * @param aExpected
84      *            Expected result.
85      * @param aActual
86      *            Actual result.
87      */
88     public static <T> void assertEquals(String aMsg, T aExpected,
89             T aActual) {
90         if (aExpected instanceof Object[]) {
91             AssertionUtils.assertEquals(aMsg, (Object[]) aExpected,
92                     (Object[]) aActual);
93
94             return;
95         }
96
97         TestCase.assertEquals(aMsg, aExpected, aActual);
98     }
99
100     /**
101      * Asserts that two maps are equal by comparing all keys and by checking
102      * that the values for the same keys are the same.
103      * 
104      * @param aMsg
105      *            Message.
106      * @param aExpectedMap
107      *            Expected result.
108      * @param aActual
109      *            Actual result.
110      */
111     public static <Key,Value> void assertEquals(String aMsg, 
112             Map<Key,Value> aExpectedMap, Map<Key,Value> aActual) {
113         TestCase.assertEquals("Map sizes differ", aExpectedMap.size(), aActual
114                 .size());
115
116         Set keys = aExpectedMap.keySet();
117
118         for (Iterator i = keys.iterator(); i.hasNext();) {
119             String key = (String) i.next();
120             TestCase.assertTrue("Map does not containg entry for key:" + key,
121                     aActual.containsKey(key));
122             AssertionUtils.assertEquals("Value of key " + key + " of map",
123                     aExpectedMap.get(key), aActual.get(key));
124         }
125     }
126    
127     public static interface ErroneousCode { 
128         void run() throws Exception; 
129     }
130     
131     /** 
132      * Asserts that an exception occurs.
133      * @param aRunnable Test cases should create a subclass of this which contains the 
134      * code that should throw an exception.   
135      * @param aType Type of exception that is expected.   
136      */
137     public static void assertException(ErroneousCode aObject, Class aType) { 
138         try { 
139                 aObject.run();
140                 throw new RuntimeException("No exception occurred");
141         } catch (Throwable t) { 
142                 if ( aType.isInstance(t)) { 
143                         return; // ok 
144                 }
145                 else { 
146                         throw new RuntimeException(t);
147                 }
148         }
149     }
150 }