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