KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > cache > pojo > collection > CachedMapTest


1 package org.jboss.cache.pojo.collection;
2
3 import junit.framework.Test;
4 import junit.framework.TestCase;
5 import junit.framework.TestSuite;
6 import org.apache.commons.logging.Log;
7 import org.apache.commons.logging.LogFactory;
8 import org.jboss.aop.proxy.ClassProxy;
9 import org.jboss.cache.pojo.PojoCache;
10 import org.jboss.cache.pojo.PojoCacheFactory;
11 import org.jboss.cache.pojo.PojoCacheException;
12 import org.jboss.cache.pojo.test.Address;
13
14 import java.io.Serializable JavaDoc;
15 import java.util.Collection JavaDoc;
16 import java.util.HashMap JavaDoc;
17 import java.util.HashSet JavaDoc;
18 import java.util.Iterator JavaDoc;
19 import java.util.Map JavaDoc;
20 import java.util.Set JavaDoc;
21
22 /**
23  * Map interface testing.
24  *
25  * @author Ben Wang
26  */

27
28 public class CachedMapTest extends TestCase
29 {
30    Log log = LogFactory.getLog(CachedMapTest.class);
31    PojoCache cache_;
32    Map JavaDoc hobbies;
33
34    public CachedMapTest(String JavaDoc name)
35    {
36       super(name);
37    }
38
39    protected void setUp() throws Exception JavaDoc
40    {
41       super.setUp();
42       log.info("setUp() ....");
43       String JavaDoc configFile = "META-INF/local-service.xml";
44       boolean toStart = false;
45       cache_ = PojoCacheFactory.createCache(configFile, toStart);
46       cache_.start();
47
48       stage();
49    }
50
51    protected void tearDown() throws Exception JavaDoc
52    {
53       super.tearDown();
54       cache_.stop();
55    }
56
57    protected void stage() throws Exception JavaDoc
58    {
59       hobbies = new HashMap JavaDoc();
60       hobbies.put("1", "golf");
61       hobbies.put("2", "tennis");
62       hobbies.put("3", "polo");
63
64       cache_.attach("/person/test7", hobbies);
65
66       hobbies = (Map JavaDoc) cache_.find("/person/test7");
67       assertEquals("Map size", 3, hobbies.size());
68
69       if (!(hobbies instanceof ClassProxy || hobbies instanceof Map JavaDoc))
70       {
71          fail("testPut(): hobbies is not instance of ClassProxy nor Map");
72       }
73    }
74
75    /**
76     * Test simple put
77     *
78     * @throws Throwable
79     */

80    public void testPut() throws Throwable JavaDoc
81    {
82       int size = hobbies.size();
83       assertEquals("Size is ", 3, size);
84
85       hobbies.put("6", "baseball");
86       size = hobbies.size();
87       assertEquals("Size is ", 4, size);
88
89    }
90
91    public void testAddAndRemoveIndex() throws Throwable JavaDoc
92    {
93       hobbies.put("4", "baseball");
94       int size = hobbies.size();
95       assertEquals("Size is ", 4, size);
96
97       assertTrue("Skill contain Golf ", hobbies.containsKey("3"));
98
99       hobbies.remove("3");
100       size = hobbies.size();
101       assertEquals("Size is ", 3, size);
102       assertFalse("Skill does not contain 3 anymore ", hobbies.containsKey("3"));
103
104       hobbies.clear();
105       size = hobbies.size();
106       assertEquals("Size is ", 0, size);
107
108       assertTrue("Should be empty", hobbies.isEmpty());
109    }
110
111    public void testPutAllEtc() throws Throwable JavaDoc
112    {
113       Map JavaDoc map = new HashMap JavaDoc();
114       map.put("4", "pingpong");
115       map.put("5", "handball");
116
117       hobbies.putAll(map);
118       int size = hobbies.size();
119       assertEquals("Size is ", 5, size);
120
121       assertTrue("Key is ", hobbies.containsKey("4"));
122
123       Set JavaDoc keys = hobbies.keySet();
124       assertEquals("Key size ", 5, keys.size());
125
126       Set JavaDoc entries = hobbies.entrySet();
127       assertEquals("Entry size ", 5, entries.size());
128
129    }
130
131    public void testLongValue() throws Throwable JavaDoc
132    {
133       Long JavaDoc val = new Long JavaDoc("8225676592564383");
134       Long JavaDoc val2 = 8225676592564383L;
135       assertTrue(0 == val.compareTo(val2)); // sanity check
136
hobbies.put(val, "prateek");
137       assertTrue(hobbies.containsKey(val));
138       assertTrue(hobbies.get(val).equals("prateek"));
139    }
140
141    public void testEntrySet() throws Throwable JavaDoc
142    {
143       System.out.println("Map " + hobbies.toString());
144       for (Iterator JavaDoc i = hobbies.entrySet().iterator(); i.hasNext();)
145       {
146          Map.Entry JavaDoc entry = (Map.Entry JavaDoc) i.next();
147          System.out.println("Entry key and value " + entry.getKey() + " " + entry.getValue());
148       }
149    }
150
151    public void testValues() throws Throwable JavaDoc
152    {
153       System.out.println("Map " + hobbies.toString());
154
155       Set JavaDoc correct = new HashSet JavaDoc();
156       correct.add("golf");
157       correct.add("tennis");
158       correct.add("polo");
159
160       Collection JavaDoc values = hobbies.values();
161       assertEquals("Correct number of elements in value collection",
162               correct.size(), values.size());
163
164       Iterator JavaDoc iter = null;
165       for (iter = correct.iterator(); iter.hasNext();)
166          assertTrue(values.contains(iter.next()));
167
168       for (iter = values.iterator(); iter.hasNext();)
169       {
170          Object JavaDoc value = iter.next();
171          assertTrue(value + " expected", correct.remove(value));
172       }
173       assertTrue("No missing elements from iterator", correct.size() == 0);
174
175       iter.remove();
176       assertTrue("2 elements left after remove via iter", values.size() == 2);
177       assertTrue("Iter removal reflected in map", hobbies.size() == 2);
178
179       Object JavaDoc[] data = values.toArray();
180       assertTrue("2 elements in values array", data.length == 2);
181
182       values.remove(data[0]);
183       assertTrue("1 element left after remove", values.size() == 1);
184       assertTrue("Removal reflected in map", hobbies.size() == 1);
185
186       values.clear();
187       assertTrue("0 elements left after clear", values.size() == 0);
188       assertTrue("Clear reflected in map", hobbies.size() == 0);
189    }
190
191    public void testContainsValue() throws Throwable JavaDoc
192    {
193       System.out.println("Map " + hobbies.toString());
194       assertTrue("contains golf", hobbies.containsValue("golf"));
195       assertTrue("contains tennis", hobbies.containsValue("tennis"));
196       assertTrue("contains polo", hobbies.containsValue("polo"));
197       assertFalse("does not contain squash", hobbies.containsValue("squash"));
198    }
199
200    public void testEquals1() throws Throwable JavaDoc
201    {
202       Map JavaDoc map = new HashMap JavaDoc();
203       map.put("1", "test");
204       map.put("4", "test");
205       map.put("2", "tennis");
206       assertFalse("Map should not be the same ", map.equals(hobbies));
207    }
208
209    public void testEquals2() throws Throwable JavaDoc
210    {
211       Map JavaDoc map1 = new HashMap JavaDoc();
212       cache_.attach("map1", map1);
213       map1 = (Map JavaDoc) cache_.find("map1");
214       map1.put("1", "test");
215
216       Map JavaDoc map2 = new HashMap JavaDoc();
217       cache_.attach("map2", map2);
218       map2 = (Map JavaDoc) cache_.find("map2");
219       map2.put("1", "me");
220
221       assertFalse("Map should not be the same ", map1.equals(map2));
222    }
223
224    public void testEquals3() throws Throwable JavaDoc
225    {
226       Map JavaDoc map1 = new HashMap JavaDoc();
227       cache_.attach("map1", map1);
228       map1 = (Map JavaDoc) cache_.find("map1");
229       map1.put("1", "test");
230       map1.put("2", "test");
231
232       Map JavaDoc map2 = new HashMap JavaDoc();
233       cache_.attach("map2", map2);
234       map2 = (Map JavaDoc) cache_.find("map2");
235       map2.put("1", "me");
236       map2.put("2", "me");
237
238       assertFalse("Map should not be the same ", map1.equals(map2));
239    }
240
241    public void testAttachAndDetach() throws Exception JavaDoc
242    {
243       Map JavaDoc map = new HashMap JavaDoc();
244       map.put("1", "English");
245       map.put("2", "French");
246       map.put("3", "Taiwanese");
247
248       cache_.attach("/test", map); // attach
249
map = (Map JavaDoc) cache_.find("/test");
250       assertEquals("Size ", 3, map.size());
251
252       map = (Map JavaDoc) cache_.detach("/test"); // detach
253
assertEquals("Size ", 3, map.size());
254
255       System.out.println("**** End of cache content **** ");
256       map.remove("2");
257       map.put(2, "Hoklo");
258       assertEquals("Size ", 3, map.size());
259       assertEquals("Content ", "Hoklo", map.get(2));
260
261       // Try to re-attach
262
cache_.attach("/test", map);
263       map.remove("3");
264       assertEquals("Size ", 2, map.size());
265    }
266
267    public void testPojoAttachAndDetach() throws Exception JavaDoc
268    {
269       Address add1 = new Address();
270       add1.setCity("San Jose");
271       add1.setZip(95123);
272
273       Address add2 = new Address();
274       add2.setCity("Sunnyvale");
275       add2.setZip(94086);
276
277       Address add3 = new Address();
278       add3.setCity("Santa Clara");
279       add3.setZip(951131);
280
281       Map JavaDoc map = new HashMap JavaDoc();
282       map.put("1", add1);
283       map.put("2", add2);
284       map.put("3", add3);
285
286       cache_.attach("/test", map); // attach
287
map = (Map JavaDoc) cache_.find("/test");
288       assertEquals("Size ", 3, map.size());
289
290       map = (Map JavaDoc) cache_.detach("/test");
291       assertEquals("Size ", 3, map.size());
292
293       System.out.println("**** End of cache content **** ");
294       map.remove("2");
295       map.put("2", add2);
296       assertEquals("Size ", 3, map.size());
297       assertEquals("Content ", add2, map.get("2"));
298
299       // Try to re-attach
300
cache_.attach("/test", map);
301       map.remove("2");
302       assertEquals("Size ", 2, map.size());
303    }
304
305    public void testKeyAsObject() throws Exception JavaDoc
306    {
307       SerializableKeyValue key = new SerializableKeyValue(42, "Novell");
308       Address add1 = new Address();
309       add1.setCity("Waltham");
310       add1.setStreet("404 Wyman Street");
311       add1.setZip(02451);
312
313       Map JavaDoc map = new HashMap JavaDoc();
314       map.put(key, add1);
315       cache_.attach("/keytest", map);
316       Map JavaDoc ref = (Map JavaDoc) cache_.find("/keytest");
317
318       Iterator JavaDoc iter = ref.keySet().iterator();
319       assertTrue(iter.hasNext());
320       Object JavaDoc keyFromMap = iter.next();
321       assertEquals("original key is same as key in pojocache map, key class=" +
322               key.getClass().getName() + ", keyFromMap class=" + keyFromMap.getClass().getName(),
323               key, keyFromMap);
324       assertEquals("local map is equal to pojocache map", map, ref);
325    }
326
327    public void testNonSerializableKeyAsObject() throws Exception JavaDoc
328    {
329       // negative test as we should get a java.io.NotSerializableException
330
NotSerializableKeyValue key = new NotSerializableKeyValue(42, "Novell");
331       Address add1 = new Address();
332       add1.setCity("Waltham");
333       add1.setStreet("404 Wyman Street");
334       add1.setZip(02451);
335
336       Map JavaDoc map = new HashMap JavaDoc();
337       map.put(key, add1);
338       try
339       {
340          cache_.attach("/keytest", map); // this should throw RuntimeException with cause of java.io.NotSerializableException
341
fail("failed to get expected runtimeException when adding nonserializable key to pojocache map");
342       }
343       catch (PojoCacheException e)
344       {
345          Throwable JavaDoc t = e;
346
347          assertTrue("we got expected PojoCacheException "
348                  + t.getCause().getClass().getName(), t.getCause() instanceof PojoCacheException);
349       }
350       map.clear();
351       cache_.attach("/keytest", map); // this should succeed
352
Map JavaDoc ref = (Map JavaDoc) cache_.find("/keytest");
353
354       // try adding nonserializable key to pojocache based map
355
try
356       {
357          ref.put(key, add1); // this should throw RuntimeException with cause of java.io.NotSerializableException
358
fail("failed to get expected runtimeException when putting nonserializable key to pojocache map");
359       }
360       catch (RuntimeException JavaDoc e)
361       {
362          Throwable JavaDoc t = e;
363
364          assertTrue("we got expected PojoCacheException "
365                  + t.getClass().getName(), t instanceof PojoCacheException);
366       }
367    }
368
369    public static Test suite() throws Exception JavaDoc
370    {
371       return new TestSuite(CachedMapTest.class);
372    }
373
374    public static void main(String JavaDoc[] args) throws Exception JavaDoc
375    {
376       junit.textui.TestRunner.run(suite());
377    }
378
379    static class SerializableKeyValue implements Serializable JavaDoc
380    {
381       Integer JavaDoc ivalue;
382       String JavaDoc svalue;
383
384       SerializableKeyValue(Integer JavaDoc ivalue, String JavaDoc svalue)
385       {
386          this.ivalue = ivalue;
387          this.svalue = svalue;
388       }
389
390       public int hashCode()
391       {
392          return ivalue.hashCode() + svalue.hashCode();
393       }
394
395       public boolean equals(Object JavaDoc o)
396       {
397          if (o == this)
398          {
399             return true;
400          }
401          if (!(o instanceof SerializableKeyValue))
402          {
403             System.out.println("equals: not instanceof SerializableKeyValue , it is a " + o.getClass().getName());
404             return false;
405          }
406          SerializableKeyValue val = (SerializableKeyValue) o;
407          return val.ivalue == this.ivalue && val.svalue == this.svalue;
408       }
409    }
410
411    static class NotSerializableKeyValue
412    {
413       Integer JavaDoc ivalue;
414       String JavaDoc svalue;
415
416       NotSerializableKeyValue(Integer JavaDoc ivalue, String JavaDoc svalue)
417       {
418          this.ivalue = ivalue;
419          this.svalue = svalue;
420       }
421
422       public int hashCode()
423       {
424          return ivalue.hashCode() + svalue.hashCode();
425       }
426
427       public boolean equals(Object JavaDoc o)
428       {
429          if (o == this)
430          {
431             return true;
432          }
433          if (!(o instanceof SerializableKeyValue))
434          {
435             System.out.println("equals: not instanceof SerializableKeyValue , it is a " + o.getClass().getName());
436             return false;
437          }
438          SerializableKeyValue val = (SerializableKeyValue) o;
439          return val.ivalue == this.ivalue && val.svalue == this.svalue;
440       }
441    }
442
443 }
444
445
Popular Tags