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.cache.pojo.PojoCache; |
9 |
| import org.jboss.cache.pojo.PojoCacheFactory; |
10 |
| import org.jboss.cache.pojo.test.Address; |
11 |
| |
12 |
| import java.io.PrintWriter; |
13 |
| import java.io.StringWriter; |
14 |
| import java.util.ArrayList; |
15 |
| import java.util.Arrays; |
16 |
| import java.util.Collection; |
17 |
| import java.util.Collections; |
18 |
| import java.util.HashSet; |
19 |
| import java.util.Iterator; |
20 |
| import java.util.LinkedList; |
21 |
| import java.util.List; |
22 |
| import java.util.NoSuchElementException; |
23 |
| import java.util.Set; |
24 |
| |
25 |
| |
26 |
| |
27 |
| |
28 |
| |
29 |
| |
30 |
| |
31 |
| public class CachedSetTest extends TestCase |
32 |
| { |
33 |
| Log log = LogFactory.getLog(CachedSetTest.class); |
34 |
| PojoCache cache_; |
35 |
| Set skills; |
36 |
| |
37 |
24
| public CachedSetTest(String name)
|
38 |
| { |
39 |
24
| super(name);
|
40 |
| } |
41 |
| |
42 |
24
| protected void setUp() throws Exception
|
43 |
| { |
44 |
24
| super.setUp();
|
45 |
24
| log.info("setUp() ....");
|
46 |
24
| String configFile = "META-INF/local-service.xml";
|
47 |
24
| boolean toStart = false;
|
48 |
24
| cache_ = PojoCacheFactory.createCache(configFile, toStart);
|
49 |
24
| cache_.start();
|
50 |
| |
51 |
24
| stage();
|
52 |
| } |
53 |
| |
54 |
24
| protected void tearDown() throws Exception
|
55 |
| { |
56 |
24
| super.tearDown();
|
57 |
24
| cache_.stop();
|
58 |
| } |
59 |
| |
60 |
24
| protected void stage() throws Exception
|
61 |
| { |
62 |
24
| skills = new HashSet();
|
63 |
24
| skills.add("Java");
|
64 |
24
| skills.add("C++");
|
65 |
24
| skills.add("Perl");
|
66 |
| |
67 |
24
| cache_.attach("/person/test7", skills);
|
68 |
24
| skills = (Set) cache_.find("/person/test7");
|
69 |
24
| int size = skills.size();
|
70 |
24
| assertEquals("Size is ", 3, size);
|
71 |
| } |
72 |
| |
73 |
2
| public void testClear() throws Throwable
|
74 |
| { |
75 |
2
| int size = skills.size();
|
76 |
2
| assertEquals("Size is ", 3, size);
|
77 |
| |
78 |
2
| skills.clear();
|
79 |
2
| size = skills.size();
|
80 |
2
| assertEquals("Size is ", 0, size);
|
81 |
| |
82 |
2
| assertTrue("Should be empty", skills.isEmpty());
|
83 |
| } |
84 |
| |
85 |
2
| public void testAddAndRemoveIndex() throws Throwable
|
86 |
| { |
87 |
2
| skills.add("Golf");
|
88 |
2
| int size = skills.size();
|
89 |
2
| assertEquals("Size is ", 4, size);
|
90 |
| |
91 |
2
| skills.add("Golf");
|
92 |
2
| size = skills.size();
|
93 |
2
| assertEquals("Size is ", 4, size);
|
94 |
| |
95 |
2
| assertTrue("Skill shuold contain Golf ", skills.contains("Golf"));
|
96 |
2
| skills.remove("C++");
|
97 |
2
| size = skills.size();
|
98 |
2
| assertEquals("Size is ", 3, size);
|
99 |
2
| assertFalse("Skill does not contain C++ anymore ", skills.contains("C++"));
|
100 |
| |
101 |
2
| skills.add("Golf");
|
102 |
2
| size = skills.size();
|
103 |
2
| assertEquals("Size is ", 3, size);
|
104 |
2
| skills.clear();
|
105 |
2
| size = skills.size();
|
106 |
2
| assertEquals("Size is ", 0, size);
|
107 |
| |
108 |
2
| assertTrue("Should be empty", skills.isEmpty());
|
109 |
| } |
110 |
| |
111 |
| private static class DumbObject implements java.io.Serializable |
112 |
| { |
113 |
| int i; |
114 |
6
| DumbObject(int i) { this.i = i; }
|
115 |
44
| public int hashCode()
|
116 |
| { |
117 |
44
| return 0;
|
118 |
| } |
119 |
10
| public String toString()
|
120 |
| { |
121 |
10
| return "" + i;
|
122 |
| } |
123 |
| } |
124 |
| |
125 |
2
| public void testConflictingHash() throws Exception
|
126 |
| { |
127 |
2
| Set set = new HashSet();
|
128 |
2
| String nulls = null;
|
129 |
2
| DumbObject o1 = new DumbObject(1);
|
130 |
2
| DumbObject o2 = new DumbObject(2);
|
131 |
2
| DumbObject o3 = new DumbObject(3);
|
132 |
2
| set.add(o1);
|
133 |
2
| set.add(o2);
|
134 |
2
| set.add(o3);
|
135 |
2
| set.add(nulls);
|
136 |
2
| Set set2 = Collections.unmodifiableSet(new HashSet(set));
|
137 |
| |
138 |
2
| cache_.attach("/test", set);
|
139 |
2
| set = (Set) cache_.find("/test");
|
140 |
2
| assertEquals("Same", set2, set);
|
141 |
2
| assertEquals(true, set.remove(o2));
|
142 |
2
| assertEquals(true, set.remove(nulls));
|
143 |
2
| assertEquals(false, set.remove(o2));
|
144 |
2
| assertEquals("Same minus 2 ", set2.size()-2, set.size());
|
145 |
2
| assertEquals("set " + set, true, set.add(o2));
|
146 |
2
| assertEquals("set " + set, true, set.add(nulls));
|
147 |
2
| assertEquals(false, set.add(o2));
|
148 |
2
| assertEquals(false, set.add(nulls));
|
149 |
2
| assertEquals("Same", set2, set);
|
150 |
| } |
151 |
| |
152 |
2
| public void testAddAndRemoveAll() throws Throwable
|
153 |
| { |
154 |
2
| List list = new ArrayList();
|
155 |
2
| list.add("Tennis");
|
156 |
2
| list.add("Polo");
|
157 |
2
| list.add("Baseball");
|
158 |
| |
159 |
2
| skills.addAll((Collection) list);
|
160 |
2
| int size = skills.size();
|
161 |
2
| assertEquals("Size is ", 6, size);
|
162 |
2
| assertTrue("Skill contains Polo ", skills.contains("Polo"));
|
163 |
| |
164 |
2
| skills.removeAll((Collection) list);
|
165 |
2
| size = skills.size();
|
166 |
2
| assertEquals("Size is ", 3, size);
|
167 |
2
| assertFalse("Skill does not contain Polo ", skills.contains("Polo"));
|
168 |
2
| assertTrue("Skill contains C++ ", skills.contains("C++"));
|
169 |
| |
170 |
| } |
171 |
| |
172 |
2
| public void testRemoveAndAdd()
|
173 |
| { |
174 |
2
| assertTrue(skills.remove("C++"));
|
175 |
2
| assertTrue(skills.add("C++"));
|
176 |
2
| assertEquals("removeAndAdd: size is 3", 3, skills.size());
|
177 |
| } |
178 |
| |
179 |
2
| public void testIterator()
|
180 |
| { |
181 |
2
| Iterator it = skills.iterator();
|
182 |
2
| int counter = 0;
|
183 |
2
| while (it.hasNext())
|
184 |
| { |
185 |
6
| counter++;
|
186 |
6
| it.next();
|
187 |
6
| it.remove();
|
188 |
| } |
189 |
| |
190 |
2
| assertEquals("iterator: Size should be ", 3, counter);
|
191 |
2
| assertEquals("iterator: Skills should be empty ", 0, skills.size());
|
192 |
| |
193 |
2
| List list = new ArrayList();
|
194 |
2
| list.add("Tennis");
|
195 |
2
| list.add("Polo");
|
196 |
2
| list.add("Baseball");
|
197 |
2
| list.add("Soccer");
|
198 |
2
| list.add("Hockey");
|
199 |
2
| list.add("Lacrosse");
|
200 |
2
| skills.addAll(list);
|
201 |
2
| it = skills.iterator();
|
202 |
2
| while (it.hasNext())
|
203 |
| { |
204 |
12
| counter++;
|
205 |
12
| if ("Polo".equals(it.next()))
|
206 |
| { |
207 |
2
| it.remove();
|
208 |
| } |
209 |
| } |
210 |
2
| assertFalse("iterator: item removed via iterator", skills.contains("Polo"));
|
211 |
2
| assertTrue("iterator: item not removed via iterator", skills.contains("Lacrosse"));
|
212 |
| |
213 |
| |
214 |
2
| list = new ArrayList();
|
215 |
2
| list.add("Tennis");
|
216 |
2
| list.add("Polo");
|
217 |
2
| list.add("Baseball");
|
218 |
2
| skills.addAll(list);
|
219 |
2
| it = skills.iterator();
|
220 |
2
| while (it.hasNext())
|
221 |
| { |
222 |
12
| it.next();
|
223 |
| } |
224 |
2
| try
|
225 |
| { |
226 |
2
| it.next();
|
227 |
0
| fail("iterator: Didn't fail on next() when hasNext() == false");
|
228 |
| } |
229 |
| catch (NoSuchElementException good) |
230 |
| { |
231 |
| } |
232 |
| |
233 |
| |
234 |
2
| it = skills.iterator();
|
235 |
2
| try
|
236 |
| { |
237 |
2
| it.remove();
|
238 |
| } |
239 |
| catch (IllegalStateException good) |
240 |
| { |
241 |
| |
242 |
| } |
243 |
| catch (Exception e) |
244 |
| { |
245 |
0
| StringWriter stackTrace = new StringWriter();
|
246 |
0
| e.printStackTrace(new PrintWriter(stackTrace));
|
247 |
0
| fail("iterator: failed with incorrect exception type when removing " +
|
248 |
| "without first calling next() -- " + e.getClass().getName() + ". stackTrace=" + stackTrace); |
249 |
| } |
250 |
| |
251 |
| |
252 |
| } |
253 |
| |
254 |
2
| public void testEquals() throws Throwable
|
255 |
| { |
256 |
2
| Set set = (Set) cache_.find("/person/test7");
|
257 |
2
| assertTrue("iterator: List should be the same ", set.equals(skills));
|
258 |
2
| set = new HashSet();
|
259 |
2
| set.add("German");
|
260 |
2
| set.add("test");
|
261 |
2
| set.add("English");
|
262 |
2
| assertFalse("List should not be the same ", set.equals(skills));
|
263 |
2
| assertFalse("List should not be the same ", skills.equals(set));
|
264 |
| } |
265 |
| |
266 |
| |
267 |
2
| public void testAttachAndDetach() throws Exception
|
268 |
| { |
269 |
2
| Set set = new HashSet();
|
270 |
2
| set.add("English");
|
271 |
2
| set.add("French");
|
272 |
2
| set.add("Taiwanese");
|
273 |
| |
274 |
2
| cache_.attach("/test", set);
|
275 |
2
| set = (Set) cache_.find("/test");
|
276 |
2
| assertEquals("Size ", 3, set.size());
|
277 |
| |
278 |
2
| set = (Set) cache_.detach("/test");
|
279 |
2
| assertEquals("Size ", 3, set.size());
|
280 |
| |
281 |
2
| System.out.println("**** End of cache content **** ");
|
282 |
2
| set.remove("French");
|
283 |
2
| set.add("Hoklo");
|
284 |
2
| assertEquals("Size ", 3, set.size());
|
285 |
2
| assertTrue("Content ", set.contains("Hoklo"));
|
286 |
| |
287 |
| |
288 |
2
| cache_.attach("/test", set);
|
289 |
2
| set.remove("Taiwanese");
|
290 |
2
| assertEquals("Size ", 2, set.size());
|
291 |
| } |
292 |
| |
293 |
2
| public void testPojoAttachAndDetach() throws Exception
|
294 |
| { |
295 |
2
| Address add1 = new Address();
|
296 |
2
| add1.setCity("San Jose");
|
297 |
2
| add1.setZip(95123);
|
298 |
| |
299 |
2
| Address add2 = new Address();
|
300 |
2
| add2.setCity("Sunnyvale");
|
301 |
2
| add2.setZip(94086);
|
302 |
| |
303 |
2
| Address add3 = new Address();
|
304 |
2
| add3.setCity("Santa Clara");
|
305 |
2
| add3.setZip(951131);
|
306 |
| |
307 |
2
| Set set = new HashSet();
|
308 |
2
| set.add(add1);
|
309 |
2
| set.add(add2);
|
310 |
2
| set.add(add3);
|
311 |
| |
312 |
2
| cache_.attach("/test", set);
|
313 |
2
| set = (Set) cache_.find("/test");
|
314 |
2
| assertEquals("Size ", 3, set.size());
|
315 |
| |
316 |
2
| set = (Set) cache_.detach("/test");
|
317 |
2
| assertEquals("Size ", 3, set.size());
|
318 |
| |
319 |
2
| System.out.println("**** End of cache content **** ");
|
320 |
2
| set.remove(add2);
|
321 |
2
| set.add(add2);
|
322 |
2
| assertEquals("Size ", 3, set.size());
|
323 |
2
| assertTrue("Content ", set.contains(add2));
|
324 |
| |
325 |
| |
326 |
2
| cache_.attach("/test", set);
|
327 |
2
| set.remove(add2);
|
328 |
2
| assertEquals("Size ", 2, set.size());
|
329 |
| } |
330 |
| |
331 |
2
| public void testToArray() throws Exception
|
332 |
| { |
333 |
2
| Object[] arr = skills.toArray();
|
334 |
2
| assertEquals("toArray: array length is correct", 3, arr.length);
|
335 |
2
| testLanguagesFound(arr);
|
336 |
| |
337 |
2
| Object[] arr1 = skills.toArray(arr);
|
338 |
2
| assertTrue("toArray: arrays match", Arrays.equals(arr, arr1));
|
339 |
| |
340 |
2
| arr = new Object[5];
|
341 |
2
| arr = skills.toArray(arr);
|
342 |
2
| assertEquals("toArray: array length is correct", 5, arr.length);
|
343 |
2
| testLanguagesFound(arr);
|
344 |
2
| assertEquals(null, arr[3]);
|
345 |
2
| assertEquals(null, arr[4]);
|
346 |
| |
347 |
2
| arr = new Object[2];
|
348 |
2
| arr = skills.toArray(arr);
|
349 |
2
| assertEquals("toArray: array length is correct", 3, arr.length);
|
350 |
2
| testLanguagesFound(arr);
|
351 |
| |
352 |
| } |
353 |
| |
354 |
6
| private void testLanguagesFound(Object[] arr)
|
355 |
| { |
356 |
6
| boolean[] found = new boolean[3];
|
357 |
6
| for (int i = 0; i < arr.length; i++)
|
358 |
| { |
359 |
22
| if ("Java".equals(arr[i]))
|
360 |
6
| found[0] = true;
|
361 |
16
| else if ("C++".equals(arr[i]))
|
362 |
6
| found[1] = true;
|
363 |
10
| else if ("Perl".equals(arr[i]))
|
364 |
6
| found[2] = true;
|
365 |
| } |
366 |
6
| assertTrue("toArray: all elements found", found[0] && found[1] && found[2]);
|
367 |
| |
368 |
| } |
369 |
| |
370 |
2
| public void testRetainAll() throws Exception
|
371 |
| { |
372 |
2
| LinkedList list2 = new LinkedList();
|
373 |
2
| list2.add("Java");
|
374 |
| |
375 |
2
| assertTrue("testRetainAll", skills.retainAll(list2));
|
376 |
| |
377 |
2
| assertTrue("testRetainAll, skills size should be 1 but is " + skills.size(), skills.size() == 1);
|
378 |
2
| assertTrue("testRetainAll", skills.contains("Java"));
|
379 |
| |
380 |
| } |
381 |
| |
382 |
2
| public void testContainsAll() throws Exception
|
383 |
| { |
384 |
2
| LinkedList list2 = new LinkedList();
|
385 |
2
| list2.add("Java");
|
386 |
2
| list2.add("C++");
|
387 |
2
| list2.add("Perl");
|
388 |
| |
389 |
2
| skills.clear();
|
390 |
| |
391 |
2
| assertTrue(skills.addAll(list2));
|
392 |
2
| list2.remove("Java");
|
393 |
2
| assertTrue("testContainsAll", skills.containsAll(list2));
|
394 |
2
| skills.remove("C++");
|
395 |
2
| assertFalse("testContainsAll", skills.containsAll(list2));
|
396 |
| } |
397 |
| |
398 |
2
| public static Test suite() throws Exception
|
399 |
| { |
400 |
2
| return new TestSuite(CachedSetTest.class);
|
401 |
| } |
402 |
| |
403 |
0
| public static void main(String[] args) throws Exception
|
404 |
| { |
405 |
0
| junit.textui.TestRunner.run(suite());
|
406 |
| } |
407 |
| |
408 |
| |
409 |
| } |
410 |
| |