How to use

TestCompositeCollection

in

org.apache.commons.collections.collection

public void testAddAllToCollection() {
  setUpTest();
  one.add("1");
  two.add("2");
  c.addComposited(one, two);
  Collection toCollection = new HashSet();
  toCollection.addAll(c);
  assertTrue(toCollection.containsAll(c));
  assertEquals(c.size(), toCollection.size());
}   

/**
 * Override testUnsupportedRemove, since the default impl expects removeAll,
 * retainAll and iterator().remove to throw
 */
public void testUnsupportedRemove() {    
  resetFull();
  try {
    collection.remove(null);
    fail("remove should raise UnsupportedOperationException");
  } catch (UnsupportedOperationException e) {
    // expected
  }
  verify();
}

/**
 * Full collection should look like a collection with 4 elements
 */
public Collection makeConfirmedFullCollection() {
  Collection collection = new HashSet();
  collection.addAll(Arrays.asList(getFullElements()));
  return collection;
}

public void testRemoveAll() {
  setUpMutatorTest();
  one.add("1");
  two.add("2");
  two.add("1");
  c.addComposited(one, two);
  c.removeAll(one);
  assertTrue(!c.contains("1"));
  assertTrue(!one.contains("1"));
  assertTrue(!two.contains("1"));
}

public void testClear() {
  setUpTest();
  one.add("1");
  two.add("2");
  c.addComposited(one, two);
  c.clear();
  assertTrue(one.isEmpty());
  assertTrue(two.isEmpty());
  assertTrue(c.isEmpty());
}

  public void testRemoveComposited() {
    setUpMutatorTest();
    one.add("1");
    two.add("2");
    two.add("1");
    c.addComposited(one, two);    
    c.removeComposited(one);
    assertTrue(c.contains("1"));
    assertEquals(c.size(), 2);
  }
}

public void testSize() {
  setUpTest();
  HashSet set = new HashSet();
  set.add("a");
  set.add("b");
  c.addComposited(set);
  assertEquals(set.size(), c.size());
}

protected void setUpMutatorTest() {
  setUpTest();
  c.setMutator(new CompositeCollection.CollectionMutator() {
    public boolean add(CompositeCollection composite, 
    Collection[] collections, Object obj) {
      for (int i = 0; i < collections.length; i++) {
        collections[i].add(obj);
      }
      return true;
    }
    
    public boolean addAll(CompositeCollection composite, 
    Collection[] collections, Collection coll) {
      for (int i = 0; i < collections.length; i++) {
        collections[i].addAll(coll);
      }
      return true;
    }
    
    public boolean remove(CompositeCollection composite, 
    Collection[] collections, Object obj) {
      for (int i = 0; i < collections.length; i++) {
        collections[i].remove(obj);
      }
      return true;
    }
  });
}
    

public static Test suite() {
  TestSuite suite = new TestSuite();
  
  suite.addTest(TestCompositeCollection.suite());
  suite.addTest(TestPredicatedCollection.suite());
  suite.addTest(TestSynchronizedCollection.suite());
  suite.addTest(TestTransformedCollection.suite());
  suite.addTest(TestUnmodifiableCollection.suite());
  
  return suite;
}
  

public void testRetainAll() {
  setUpTest();
  one.add("1");
  one.add("2");
  two.add("1");
  c.addComposited(one);
  c.retainAll(two);
  assertTrue(!c.contains("2"));
  assertTrue(!one.contains("2"));
  assertTrue(c.contains("1"));
  assertTrue(one.contains("1"));
}

public void testRemove() {
  setUpMutatorTest();
  one.add("1");
  two.add("2");
  two.add("1");
  c.addComposited(one, two);
  c.remove("1");
  assertTrue(!c.contains("1"));
  assertTrue(!one.contains("1"));
  assertTrue(!two.contains("1"));
}

public void testMultipleCollectionsSize() {
  setUpTest();
  HashSet set = new HashSet();
  set.add("a");
  set.add("b");
  c.addComposited(set);
  HashSet other = new HashSet();
  other.add("c");
  c.addComposited(other);
  assertEquals(set.size() + other.size(), c.size());
}

public void testIsEmpty() {
  setUpTest();
  assertTrue(c.isEmpty());
  HashSet empty = new HashSet();
  c.addComposited(empty);
  assertTrue(c.isEmpty());
  empty.add("a");
  assertTrue(!c.isEmpty());
}

public void testToCollection() {
  setUpTest();
  one.add("1");
  two.add("2");
  c.addComposited(one, two);
  Collection foo = c.toCollection();
  assertTrue(foo.containsAll(c));
  assertEquals(c.size(), foo.size());
  one.add("3");
  assertTrue(!foo.containsAll(c));
}

/**
 * Full collection consists of 4 collections, each with one element
 */
public Collection makeFullCollection() {
  CompositeCollection compositeCollection = new CompositeCollection();
  Object[] elements = getFullElements();
  for (int i = 0; i < elements.length; i++) {
    Collection summand = new HashSet();
    summand.add(elements[i]);
    compositeCollection.addComposited(summand);
  }
  return compositeCollection;
}

public void testContainsAll() {
  setUpTest();
  one.add("1");
  two.add("1");
  c.addComposited(one);
  assertTrue(c.containsAll(two));
}

public void testIterator() {
  setUpTest();
  one.add("1");
  two.add("2");
  c.addComposited(one);
  c.addComposited(two);
  Iterator i = c.iterator();
  Object next = i.next();
  assertTrue(c.contains(next));
  assertTrue(one.contains(next));
  next = i.next();
  i.remove();
  assertTrue(!c.contains(next));
  assertTrue(!two.contains(next));
}

public void testAddMutator() {
  setUpTest();
  c.setMutator(new CompositeCollection.CollectionMutator() {
    public boolean add(CompositeCollection composite, 
  assertTrue(c.contains("foo"));
  assertTrue(one.contains("foo"));

public void testAddAllMutator() {
  setUpTest();
  c.setMutator(new CompositeCollection.CollectionMutator() {
    public boolean add(CompositeCollection composite, 
  two.add("foo");
  c.addAll(two);
  assertTrue(c.contains("foo"));
  assertTrue(one.contains("foo"));