1   /*
2    * Copyright 1999-2004 The Apache Software Foundation
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.apache.commons.chain.impl;
17  
18  
19  import java.util.ArrayList;
20  import java.util.Collection;
21  import java.util.HashMap;
22  import java.util.Iterator;
23  import java.util.Map;
24  import java.util.Set;
25  
26  import junit.framework.Test;
27  import junit.framework.TestCase;
28  import junit.framework.TestSuite;
29  import org.apache.commons.chain.Context;
30  
31  
32  
33  /***
34   * <p>Test case for the <code>ContextBase</code> class.</p>
35   *
36   * @author Craig R. McClanahan
37   * @version $Revision: 1.6 $ $Date: 2004/02/25 00:01:05 $
38   */
39  
40  public class ContextBaseTestCase extends TestCase {
41  
42  
43      // ---------------------------------------------------- Instance Variables
44  
45  
46      /***
47       * The {@link Context} instance under test.
48       */
49      protected Context context = null;
50  
51  
52  
53      // ---------------------------------------------------------- Constructors
54  
55      /***
56       * Construct a new instance of this test case.
57       *
58       * @param name Name of the test case
59       */
60      public ContextBaseTestCase(String name) {
61          super(name);
62      }
63  
64  
65      // -------------------------------------------------- Overall Test Methods
66  
67  
68      /***
69       * Set up instance variables required by this test case.
70       */
71      public void setUp() {
72          context = createContext();
73      }
74  
75  
76      /***
77       * Return the tests included in this test suite.
78       */
79      public static Test suite() {
80          return (new TestSuite(ContextBaseTestCase.class));
81      }
82  
83      /***
84       * Tear down instance variables required by this test case.
85       */
86      public void tearDown() {
87          context = null;
88      }
89  
90  
91      // ------------------------------------------------ Individual Test Methods
92  
93  
94      // Test ability to get, put, and remove attributes
95      public void testAttributes() {
96  
97          Object value = null;
98          checkAttributeCount(0);
99  
100         context.put("foo", "This is foo");
101         checkAttributeCount(1);
102         value = context.get("foo");
103         assertNotNull("Returned foo", value);
104         assertTrue("Returned foo type", value instanceof String);
105         assertEquals("Returned foo value", "This is foo",
106                      (String) value);
107 
108         context.put("bar", "This is bar");
109         checkAttributeCount(2);
110         value = context.get("bar");
111         assertNotNull("Returned bar", value);
112         assertTrue("Returned bar type", value instanceof String);
113         assertEquals("Returned bar value", "This is bar",
114                      (String) value);
115 
116         context.put("baz", "This is baz");
117         checkAttributeCount(3);
118         value = context.get("baz");
119         assertNotNull("Returned baz", value);
120         assertTrue("Returned baz type", value instanceof String);
121         assertEquals("Returned baz value", "This is baz",
122                      (String) value);
123 
124         context.put("baz", "This is new baz");
125         checkAttributeCount(3); // Replaced, not added
126         value = context.get("baz");
127         assertNotNull("Returned baz", value);
128         assertTrue("Returned baz type", value instanceof String);
129         assertEquals("Returned baz value", "This is new baz",
130                      (String) value);
131 
132         context.remove("bar");
133         checkAttributeCount(2);
134         assertNull("Did not return bar",
135                    context.get("bar"));
136         assertNotNull("Still returned foo",
137                       context.get("foo"));
138         assertNotNull("Still returned baz",
139                       context.get("baz"));
140 
141         context.clear();
142         checkAttributeCount(0);
143         assertNull("Did not return foo",
144                    context.get("foo"));
145         assertNull("Did not return bar",
146                    context.get("bar"));
147         assertNull("Did not return baz",
148                    context.get("baz"));
149 
150     }
151 
152 
153     // Test containsKey() and containsValue()
154     public void testContains() {
155 
156         assertTrue(!context.containsKey("bop"));
157         assertTrue(!context.containsValue("bop value"));
158         context.put("bop", "bop value");
159         assertTrue(context.containsKey("bop"));
160         assertTrue(context.containsValue("bop value"));
161         context.remove("bop");
162         assertTrue(!context.containsKey("bop"));
163         assertTrue(!context.containsValue("bop value"));
164 
165     }
166 
167 
168     // Test equals() and hashCode()
169     public void testEquals() {
170 
171         // Compare to self
172         assertTrue(context.equals(context));
173         assertTrue(context.hashCode() == context.hashCode());
174 
175         // Compare to equivalent instance
176         Context other = createContext();
177         assertTrue(context.equals(other));
178         assertTrue(context.hashCode() == other.hashCode());
179 
180         // Compare to non-equivalent instance - other modified
181         other.put("bop", "bop value");
182         assertTrue(!context.equals(other));
183         assertTrue(context.hashCode() != other.hashCode());
184 
185         // Compare to non-equivalent instance - self modified
186         other = createContext(); // reset to equivalence
187         context.put("bop", "bop value");
188         assertTrue(!context.equals(other));
189         assertTrue(context.hashCode() != other.hashCode());
190 
191     }
192 
193 
194     // Test keySet()
195     public void testKeySet() {
196 
197         Set keySet = null;
198         Collection all = new ArrayList();
199 
200         // Unsupported operations
201         keySet = context.keySet();
202         try {
203             keySet.add("bop");
204             fail("Should have thrown UnsupportedOperationException");
205         } catch (UnsupportedOperationException e) {
206             ; // Expected result
207         }
208         try {
209             Collection adds = new ArrayList();
210             adds.add("bop");
211             keySet.addAll(adds);
212             fail("Should have thrown UnsupportedOperationException");
213         } catch (UnsupportedOperationException e) {
214             ; // Expected result
215         }
216 
217         // Before-modification checks
218         keySet = context.keySet();
219         assertEquals(createContext().size(), keySet.size());
220         assertTrue(!keySet.contains("foo"));
221         assertTrue(!keySet.contains("bar"));
222         assertTrue(!keySet.contains("baz"));
223         assertTrue(!keySet.contains("bop"));
224 
225         // Add the new elements
226         context.put("foo", "foo value");
227         context.put("bar", "bar value");
228         context.put("baz", "baz value");
229         all.add("foo");
230         all.add("bar");
231         all.add("baz");
232 
233         // After-modification checks
234         keySet = context.keySet();
235         assertEquals(expectedAttributeCount() + 3, keySet.size());
236         assertTrue(keySet.contains("foo"));
237         assertTrue(keySet.contains("bar"));
238         assertTrue(keySet.contains("baz"));
239         assertTrue(!keySet.contains("bop"));
240         assertTrue(keySet.containsAll(all));
241 
242         // Remove a single element via remove()
243         context.remove("bar");
244         all.remove("bar");
245         keySet = context.keySet();
246         assertEquals(expectedAttributeCount() + 2, keySet.size());
247         assertTrue(keySet.contains("foo"));
248         assertTrue(!keySet.contains("bar"));
249         assertTrue(keySet.contains("baz"));
250         assertTrue(!keySet.contains("bop"));
251         assertTrue(keySet.containsAll(all));
252 
253         // Remove a single element via keySet.remove()
254         keySet.remove("baz");
255         all.remove("baz");
256         keySet = context.keySet();
257         assertEquals(expectedAttributeCount() + 1, keySet.size());
258         assertTrue(keySet.contains("foo"));
259         assertTrue(!keySet.contains("bar"));
260         assertTrue(!keySet.contains("baz"));
261         assertTrue(!keySet.contains("bop"));
262         assertTrue(keySet.containsAll(all));
263 
264         // Remove all elements via keySet.clear()
265         keySet.clear();
266         all.clear();
267         assertEquals(expectedAttributeCount(), keySet.size());
268         assertTrue(!keySet.contains("foo"));
269         assertTrue(!keySet.contains("bar"));
270         assertTrue(!keySet.contains("baz"));
271         assertTrue(!keySet.contains("bop"));
272         assertTrue(keySet.containsAll(all));
273 
274         // Add the new elements #2
275         context.put("foo", "foo value");
276         context.put("bar", "bar value");
277         context.put("baz", "baz value");
278         all.add("foo");
279         all.add("bar");
280         all.add("baz");
281 
282         // After-modification checks #2
283         keySet = context.keySet();
284         assertEquals(expectedAttributeCount() + 3, keySet.size());
285         assertTrue(keySet.contains("foo"));
286         assertTrue(keySet.contains("bar"));
287         assertTrue(keySet.contains("baz"));
288         assertTrue(!keySet.contains("bop"));
289         assertTrue(keySet.containsAll(all));
290 
291     }
292 
293 
294     // Test state of newly created instance
295     public void testPristine() {
296 
297         checkAttributeCount(0);
298         assertNull("No 'foo' attribute",
299                    context.get("foo"));
300 
301     }
302 
303 
304     // Test putAll()
305     public void testPutAll() {
306 
307         // Check preconditions
308         checkAttributeCount(0);
309         assertNull(context.get("foo"));
310         assertNull(context.get("bar"));
311         assertNull(context.get("baz"));
312         assertTrue(!context.containsKey("foo"));
313         assertTrue(!context.containsKey("bar"));
314         assertTrue(!context.containsKey("baz"));
315         assertTrue(!context.containsValue("foo value"));
316         assertTrue(!context.containsValue("bar value"));
317         assertTrue(!context.containsValue("baz value"));
318 
319         // Call putAll()
320         Map adds = new HashMap();
321         adds.put("foo", "foo value");
322         adds.put("bar", "bar value");
323         adds.put("baz", "baz value");
324         context.putAll(adds);
325 
326         // Check postconditions
327         checkAttributeCount(3);
328         assertEquals("foo value", (String) context.get("foo"));
329         assertEquals("bar value", (String) context.get("bar"));
330         assertEquals("baz value", (String) context.get("baz"));
331         assertTrue(context.containsKey("foo"));
332         assertTrue(context.containsKey("bar"));
333         assertTrue(context.containsKey("baz"));
334         assertTrue(context.containsValue("foo value"));
335         assertTrue(context.containsValue("bar value"));
336         assertTrue(context.containsValue("baz value"));
337 
338     }
339 
340 
341     // -------------------------------------------------------- Support Methods
342 
343 
344     // Verify the number of defined attributes
345     protected void checkAttributeCount(int expected) {
346         int actual = 0;
347         Iterator keys = context.keySet().iterator();
348         while (keys.hasNext()) {
349             Object key = (Object) keys.next();
350             actual++;
351         }
352         assertEquals("Correct attribute count",
353                      expectedAttributeCount() + expected, actual);
354         if (expected == 0) {
355             assertTrue("Context should be empty", context.isEmpty());
356         } else {
357             assertTrue("Context should not be empty", !context.isEmpty());
358         }
359     }
360 
361 
362     // Create a new instance of the appropriate Context type for this test case
363     protected Context createContext() {
364         return (new ContextBase());
365     }
366 
367 
368     // Return the expected size() for a Context for this test case
369     protected int expectedAttributeCount() {
370         return (createContext().size());
371     }
372 
373 
374 }