testfilterlist.java

一个java操作xml的完整示例

		assertEquals("bad addAll", baz, content.get(3));
		assertEquals("bad addAll", text3, content.get(4));
		assertEquals("bad addAll", comment, content.get(5));
		assertEquals("bad addAll", quux, content.get(6));
		assertEquals("bad addAll", text4, content.get(7));
		assertEquals("bad addAll", comment2, content.get(8));
		assertEquals("bad addAll", comment3, content.get(9));
		assertEquals("bad addAll", foo, comment2.getParent());
		assertEquals("bad addAll", foo, comment3.getParent());
		try {
			content.addAll(addList);
			fail("Should have thrown an IllegalArgumentException");
		} catch(IllegalArgumentException ex) {}

		List children = foo.getChildren();
		List addList2 = new ArrayList();
		Element newElement = new Element("newelement");
		Element newElement2 = new Element("newelement2");
		addList2.add(newElement);
		addList2.add(newElement2);
		children.addAll(addList2);
		assertEquals("bad addAll", 5, children.size());
		assertEquals("bad addAll", bar, children.get(0));
		assertEquals("bad addAll", baz, children.get(1));
		assertEquals("bad addAll", quux, children.get(2));
		assertEquals("bad addAll", newElement, children.get(3));
		assertEquals("bad addAll", newElement2, children.get(4));
		assertEquals("bad addAll", foo, newElement.getParent());
		assertEquals("bad addAll", foo, newElement2.getParent());
		try {
			children.addAll(addList2);
			fail("Should have thrown an IllegalArgumentException");
		} catch(IllegalArgumentException ex) {}
    }

    public void test_TCM__boolean_addAll_int_Collection() {
		List content = foo.getContent();
		List addList = new ArrayList();
		addList.add(comment2);
		addList.add(comment3);
		content.addAll(2, addList);
		assertEquals("bad addAll", 10, content.size());
		assertEquals("bad addAll", text1, content.get(0));
		assertEquals("bad addAll", bar, content.get(1));
		assertEquals("bad addAll", comment2, content.get(2));
		assertEquals("bad addAll", comment3, content.get(3));
		assertEquals("bad addAll", text2, content.get(4));
		assertEquals("bad addAll", baz, content.get(5));
		assertEquals("bad addAll", text3, content.get(6));
		assertEquals("bad addAll", comment, content.get(7));
		assertEquals("bad addAll", quux, content.get(8));
		assertEquals("bad addAll", text4, content.get(9));
		assertEquals("bad addAll", foo, comment2.getParent());
		assertEquals("bad addAll", foo, comment3.getParent());
		try {
			content.addAll(2, addList);
			fail("Should have thrown an IllegalArgumentException");
		} catch(IllegalArgumentException ex) {}

		List children = foo.getChildren();
		List addList2 = new ArrayList();
		Element newElement = new Element("newelement");
		Element newElement2 = new Element("newelement2");
		addList2.add(newElement);
		addList2.add(newElement2);
		children.addAll(0, addList2);
		assertEquals("bad addAll", 5, children.size());
		assertEquals("bad addAll", newElement, children.get(0));
		assertEquals("bad addAll", newElement2, children.get(1));
		assertEquals("bad addAll", bar, children.get(2));
		assertEquals("bad addAll", baz, children.get(3));
		assertEquals("bad addAll", quux, children.get(4));
		assertEquals("bad addAll", foo, newElement.getParent());
		assertEquals("bad addAll", foo, newElement2.getParent());
		try {
			children.addAll(0, addList2);
			fail("Should have thrown an IllegalArgumentException");
		} catch(IllegalArgumentException ex) {}
    }

    public void test_TCM__boolean_removeAll_Collection() {
		List content = foo.getContent();
		List removeList = new ArrayList();
		removeList.add(text4);
		removeList.add(comment);
		removeList.add(bar);
		removeList.add(new Integer(17)); // should have no effect.
		content.removeAll(removeList);
		assertEquals("bad removeAll", 5, content.size());
		assertEquals("bad removeAll", text1, content.get(0));
		assertEquals("bad removeAll", text2, content.get(1));
		assertEquals("bad removeAll", baz, content.get(2));
		assertEquals("bad removeAll", text3, content.get(3));
		assertEquals("bad removeAll", quux, content.get(4));
		assertEquals("bad removeAll", null, text4.getParent());
		assertEquals("bad removeAll", null, comment.getParent());
		assertEquals("bad removeAll", null, bar.getParent());

		List children = foo.getChildren();
		List removeList2 = new ArrayList();
		removeList2.add(baz);
		removeList2.add(quux);
		removeList2.add(new Integer(17)); // should have no effect.
		children.removeAll(removeList2);
		assertEquals("bad removeAll", 0, children.size());
		assertEquals("bad removeAll", null, baz.getParent());
		assertEquals("bad removeAll", null, quux.getParent());
    }

    public void test_TCM__boolean_retainAll_Collection() {
		List content = foo.getContent();
		List retainList = new ArrayList();
		retainList.add(text3);
		retainList.add(quux);
		retainList.add(text1);
		retainList.add(baz);
		retainList.add(text2);
		content.retainAll(retainList);
		assertEquals("bad retainAll", 5, content.size());
		assertEquals("bad retainAll", text1, content.get(0));
		assertEquals("bad retainAll", text2, content.get(1));
		assertEquals("bad retainAll", baz, content.get(2));
		assertEquals("bad retainAll", text3, content.get(3));
		assertEquals("bad retainAll", quux, content.get(4));
		assertEquals("bad retainAll", null, text4.getParent());
		assertEquals("bad retainAll", null, comment.getParent());
		assertEquals("bad retainAll", null, bar.getParent());

		List children = foo.getChildren();
		List retainList2 = new ArrayList();
		retainList2.add(baz);
		children.retainAll(retainList2);
		assertEquals("bad retainAll", 1, children.size());
		assertEquals("bad retainAll", null, quux.getParent());
    }

    public void test_TCM__List_subList_int_int() {
		List children = foo.getChildren();
		List content = foo.getContent();

		List contentSublist = content.subList(3, 7);	// baz, text3, comment, quux
		contentSublist.add(comment2);
		assertEquals("bad subList", 5, contentSublist.size());
		assertEquals("bad subList", baz, contentSublist.get(0));
		assertEquals("bad subList", text3, contentSublist.get(1));
		assertEquals("bad subList", comment, contentSublist.get(2));
		assertEquals("bad subList", quux, contentSublist.get(3));
		assertEquals("bad subList", comment2, contentSublist.get(4));

		List childrenSublist = children.subList(0, 2);	// bar, baz
		childrenSublist.remove(0);
		assertEquals("bad subList", 1, childrenSublist.size());
		assertEquals("bad subList", baz, childrenSublist.get(0));

		assertEquals("wrong element from get", baz, children.get(0));
		assertEquals("wrong element from get", quux, children.get(1));

		assertEquals("wrong element from get", text1, content.get(0));
		assertEquals("wrong element from get", text2, content.get(1));
		assertEquals("wrong element from get", baz, content.get(2));
		assertEquals("wrong element from get", text3, content.get(3));
		assertEquals("wrong element from get", comment, content.get(4));
		assertEquals("wrong element from get", quux, content.get(5));
		assertEquals("wrong element from get", comment2, content.get(6));
		assertEquals("wrong element from get", text4, content.get(7));
    }


	// We'll assume that this is a decent test of iterator(), 
	// listIterator(), and listIterator(int).
    public void test_TCM__ListIterator_listIterator_int() {
		List children = foo.getChildren();
		ListIterator iter = children.listIterator(1);

		// next
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertTrue("hasNext is false", iter.hasNext());
		assertEquals("wrong element from get", baz, iter.next());
		assertTrue("hasNext is false", iter.hasNext());
		assertEquals("wrong element from get", quux, iter.next());
		assertFalse("hasNext is true", iter.hasNext());

		// prev
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertEquals("wrong element from get", quux, iter.previous());
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertEquals("wrong element from get", baz, iter.previous());
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertEquals("wrong element from get", bar, iter.previous());
		assertFalse("hasPrevious is true", iter.hasPrevious());
		assertTrue("hasNext is false", iter.hasNext());

		List content = foo.getContent();
		ListIterator iter2 = content.listIterator(1);

		// next
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", bar, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", text2, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", baz, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", text3, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", comment, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", quux, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", text4, iter2.next());
		assertFalse("hasNext is true", iter2.hasNext());

		// prev
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", text4, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", quux, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", comment, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", text3, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", baz, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", text2, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", bar, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", text1, iter2.previous());
		assertFalse("hasPrevious is true", iter2.hasPrevious());
		assertTrue("hasNext is false", iter2.hasNext());

		try {
			children.listIterator(48);
			fail("Should have thrown an IndexOutOfBoundsException");
		} catch(IndexOutOfBoundsException ex) {}
		try {
			children.listIterator(-3);
			fail("Should have thrown an IndexOutOfBoundsException");
		} catch(IndexOutOfBoundsException ex) {}
		try {
			content.listIterator(48);
			fail("Should have thrown an IndexOutOfBoundsException");
		} catch(IndexOutOfBoundsException ex) {}
		try {
			content.listIterator(-3);
			fail("Should have thrown an IndexOutOfBoundsException");
		} catch(IndexOutOfBoundsException ex) {}
    }

    public void test_TCM__ListIterator_listIterator_int2() {
		List children = foo.getChildren();
		ListIterator iter = children.listIterator(1);

		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertTrue("hasNext is false", iter.hasNext());
		assertTrue("hasNext is false", iter.hasNext());
		assertEquals("wrong element from get", baz, iter.next());
		assertEquals("wrong element from get", baz, iter.previous());
		assertEquals("wrong element from get", baz, iter.next());
		assertEquals("wrong element from get", baz, iter.previous());
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertTrue("hasPrevious is false", iter.hasPrevious());
		assertEquals("wrong element from get", bar, iter.previous());
		assertEquals("wrong element from get", bar, iter.next());
		assertEquals("wrong element from get", bar, iter.previous());
		assertFalse("hasPrevious is true", iter.hasPrevious());
		assertFalse("hasPrevious is true", iter.hasPrevious());
		assertTrue("hasNext is false", iter.hasNext());
		assertTrue("hasNext is false", iter.hasNext());

		List content = foo.getContent();
		ListIterator iter2 = content.listIterator(1);

		// next
		assertEquals("wrong element from get", bar, iter2.next());
		assertEquals("wrong element from get", text2, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", baz, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", text3, iter2.next());
		assertEquals("wrong element from get", comment, iter2.next());
		assertTrue("hasNext is false", iter2.hasNext());
		assertTrue("hasNext is false", iter2.hasNext());
		assertEquals("wrong element from get", quux, iter2.next());
		assertEquals("wrong element from get", quux, iter2.previous());
		assertEquals("wrong element from get", comment, iter2.previous());
		assertEquals("wrong element from get", text3, iter2.previous());
		assertEquals("wrong element from get", baz, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertTrue("hasPrevious is false", iter2.hasNext());
		assertEquals("wrong element from get", text2, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertTrue("hasPrevious is false", iter2.hasNext());
		assertEquals("wrong element from get", text2, iter2.next());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertTrue("hasPrevious is false", iter2.hasNext());
		assertEquals("wrong element from get", text2, iter2.previous());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertTrue("hasPrevious is false", iter2.hasPrevious());
		assertEquals("wrong element from get", bar, iter2.previous());
		assertEquals("wrong element from get", text1, iter2.previous());
		assertTrue("hasNext is false", iter2.hasNext());
		assertTrue("hasNext is false", iter2.hasNext());
    }

	// When we add the first attribute or child, or when we replace the list of
	// attributes or children, we may replace the underlying list reference 
	// in the Element. We need to make sure that any previously-created FilterLists
	// somehow get updated.
    public void test_list_replacement() {
		Element el = new Element("parent");

		List attr = el.getAttributes();
		el.setAttribute("test", "test");
		assertEquals("wrong list size after adding attribute", 1, attr.size());
		ArrayList attr2 = new ArrayList();
		attr2.add(new Attribute("test", "test"));
		attr2.add(new Attribute("test2", "test2"));
		el.setAttributes(attr2);
		assertEquals("wrong list size after replacing attribute", 2, attr.size());

		List content = el.getContent();
		el.addContent(new Element("test"));
		assertEquals("wrong list size after adding content", 1, content.size());
		ArrayList content2 = new ArrayList();
		content2.add(new Element("test"));
		content2.add(new Element("test2"));
		el.setContent(content2);
		content.size();
		assertEquals("wrong list size after replacing content", 2, content.size());
	}

    public void test_TCM__ListIterator_listIterator_int3() {
        try {
            Element r = new Element("root");
            Document d = new Document().setRootElement(r);
            r.addContent(new Element("element").setText("1"));
            r.addContent(new Element("element").setText("2"));
            r.addContent(new Element("element").setText("3"));

            Element xxx = new Element("element").setText("xxx");
            Element yyy = new Element("element").setText("yyy");

            ListIterator i = r.getChildren("element").listIterator();
            while (i.hasNext()) {
                Element e = (Element) i.next();
                i.add(new Element("element").setText(e.getText() + "_x"));
                i.add(new Element("element").setText(e.getText() + "_y")); // bug1 - double add should work
            }
            i.add(xxx); // bug2 - add at end of list....
            assertEquals("previous() is not recent add()", xxx, i.previous());
            i.set(yyy);
            assertEquals("yyy not attached", r, yyy.getParent());
            assertFalse("xxx is still attached", xxx.isAncestor(r));
           
            i.remove();
           
        } catch (OutOfMemoryError oom) {
            System.gc();
            oom.printStackTrace();
            fail("ListIterator.add() caused OutOfMemory!");
        } catch (Exception e) {
            e.printStackTrace();
            fail("Unable to complete ListIterator tests");
        }
    }


	private void dump(List list) {
		System.out.println("---");
		Iterator iter = list.iterator();
		while(iter.hasNext()) {
			System.out.println("> " + iter.next());
		}
	}
}