Clover coverage report -
Coverage timestamp: Wed Jan 31 2007 15:38:53 EST
file stats: LOC: 410   Methods: 22
NCLOC: 333   Classes: 2
 
 Source file Conditionals Statements Methods TOTAL
CachedSetTest.java 100% 97.7% 95.5% 97.6%
coverage coverage
 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    * Set interface testing.
 27    *
 28    * @author Ben Wang
 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); // attach
 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    // Check for proper relationship between hasNext and next
 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    // Check for proper relationship between next and remove
 234  2 it = skills.iterator();
 235  2 try
 236    {
 237  2 it.remove();
 238    }
 239    catch (IllegalStateException good)
 240    {
 241    // behaves correctly per Iterator contract
 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); // attach
 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    // Try to re-attach
 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); // attach
 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    // Try to re-attach
 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    // should only have Java left
 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