testfilterlist.java

一个java操作xml的完整示例

		modifyFoo();

		// New contents of foo:
		// \n, comment2, comment3, \n, \n, comment, quux, \n

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

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

		// Make sure that parentage was adjusted correctly.
		assertNull("parent is not correct", bar.getParent());
		assertNull("parent is not correct", baz.getParent());
		assertTrue("parent is not correct", comment.getParent() == foo);
		assertTrue("parent is not correct", comment2.getParent() == foo);
		assertTrue("parent is not correct", comment3.getParent() == foo);
		assertTrue("parent is not correct", quux.getParent() == foo);
	}
		

    public void test_TCM__int_size() {
		// Test size on lists.
		List children = foo.getChildren();
		assertEquals("wrong size", 3, children.size());
		List content = foo.getContent();
		assertEquals("wrong size", 8, content.size());
		
		// Modify 
		modifyFoo();

		// New contents of foo:
		// \n, comment2, comment3, \n, \n, comment, quux, \n

		// Test size on already-created lists.
		assertEquals("wrong size", 1, children.size());
		assertEquals("wrong size", 7, content.size());

		// Test size on newly-created lists.
		children = foo.getChildren();
		assertEquals("wrong size", 1, children.size());
		content = foo.getContent();
		assertEquals("wrong size", 7, content.size());
		
    }

	public void testConcurrentModification() {
		// Get lists.
		List children = foo.getChildren();
		List content = foo.getContent();
		// Get iterators.
		Iterator iter = children.iterator();
		Iterator iter2 = content.iterator();

		// Modify 
		modifyFoo();

		// Try to access an already-existing iterator.
		try {
			iter.hasNext();
			fail("No concurrent modification exception.");
		} catch(ConcurrentModificationException ex) {
		}

		// Try to access an already-existing iterator.
		try {
			iter2.next();
			fail("No concurrent modification exception.");
		} catch(ConcurrentModificationException ex) {
		}

		// Try to access a newly-created iterator.
		iter = children.iterator();
		iter.hasNext();
		iter2 = content.iterator();
		iter2.next();

		assertEquals("wrong size", 1, children.size());
		assertEquals("wrong size", 7, content.size());

		// Test iterator.remove().
		iter2 = children.iterator();
		while(iter2.hasNext()) {
			iter2.next();
			iter2.remove();
		}

		assertEquals("wrong size", 0, children.size());
		assertEquals("wrong size", 6, content.size());

		// Test iterator.remove().
		iter2 = content.iterator();
		while(iter2.hasNext()) {
			iter2.next();
			iter2.remove();
		}

		assertEquals("wrong size", 0, children.size());
		assertEquals("wrong size", 0, content.size());
	}

	// Modify "foo" a bit.
	private void modifyFoo() {
		List children = foo.getChildren();
		List content = foo.getContent();
		// \n, bar, \n, baz, \n, comment, quux, \n

		children.remove(1); // remove baz
		assertEquals("wrong size", 2, children.size());
		assertEquals("wrong size", 7, content.size());
		// \n, bar, \n, \n, comment, quux, \n

		content.add(1, comment2);
		assertEquals("wrong size", 2, children.size());
		assertEquals("wrong size", 8, content.size());
		// \n, comment2, bar, \n, \n, comment, quux, \n

		content = foo.getContent();

		content.remove(3); // remove \n
		assertEquals("wrong size", 2, children.size());
		assertEquals("wrong size", 7, content.size());
		// \n, comment2, bar, \n, comment, quux, \n


		content.set(2, comment3);
		assertEquals("wrong size", 1, children.size());
		assertEquals("wrong size", 7, content.size());
		// \n, comment2, comment3, \n, comment, quux, \n
	}

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

		Object[] childrenArray = children.toArray();
		Object[] contentArray = content.toArray();

		// Make sure they're not live.
		children.remove(1);
		content.remove(comment);

		assertArrays(childrenArray, contentArray);
    }

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

		// These arrays are big enough, and don't need to be expanded.
		Object[] childrenArray = new Object[children.size()];
		Object[] contentArray = new Object[99];
		children.toArray(childrenArray);
		content.toArray(contentArray);

		assertEquals("bad toArray size", childrenArray.length, 3);
		assertEquals("bad toArray size", contentArray.length, 99);
		assertArrays(childrenArray, contentArray);


		// These arrays aren't big enough, and do need to be expanded.
		childrenArray = new Object[1];
		contentArray = new Object[2];
		childrenArray = children.toArray(childrenArray);
		contentArray = content.toArray(contentArray);

		// Make sure they're not live.
		children.remove(baz);
		content.remove(1);

		assertEquals("bad toArray size", childrenArray.length, 3);
		assertEquals("bad toArray size", contentArray.length, 8);
		assertArrays(childrenArray, contentArray);
	}

	private void assertArrays(Object[] childrenArray, Object[] contentArray)
	{
		assertEquals("bad toArray", bar, childrenArray[0]);
		assertEquals("bad toArray", baz, childrenArray[1]);
		assertEquals("bad toArray", quux, childrenArray[2]);

		assertEquals("bad toArray", text1, contentArray[0]);
		assertEquals("bad toArray", bar, contentArray[1]);
		assertEquals("bad toArray", text2, contentArray[2]);
		assertEquals("bad toArray", baz, contentArray[3]);
		assertEquals("bad toArray", text3, contentArray[4]);
		assertEquals("bad toArray", comment, contentArray[5]);
		assertEquals("bad toArray", quux, contentArray[6]);
		assertEquals("bad toArray", text4, contentArray[7]);
    }

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

		assertTrue("bad contains", !content.contains(foo));
		assertTrue("bad contains", content.contains(bar));
		assertTrue("bad contains", content.contains(baz));
		assertTrue("bad contains", content.contains(quux));
		assertTrue("bad contains", content.contains(comment));
		assertTrue("bad contains", content.contains(text1));
		assertTrue("bad contains", content.contains(text2));
		assertTrue("bad contains", content.contains(text3));
		assertTrue("bad contains", content.contains(text4));
		assertTrue("bad contains", !content.contains(comment2));
		assertTrue("bad contains", !content.contains(new Integer(17)));

		assertTrue("bad contains", !children.contains(foo));
		assertTrue("bad contains", children.contains(bar));
		assertTrue("bad contains", children.contains(baz));
		assertTrue("bad contains", children.contains(quux));
		assertTrue("bad contains", !children.contains(comment));
		assertTrue("bad contains", !children.contains(text1));
		assertTrue("bad contains", !children.contains(text2));
		assertTrue("bad contains", !children.contains(text3));
		assertTrue("bad contains", !children.contains(text4));
		assertTrue("bad contains", !children.contains(comment2));
		assertTrue("bad contains", !children.contains(new Integer(17)));
    }

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

		children.clear();

		assertEquals("bad clear", 0, children.size());
		assertEquals("bad clear", 5, content.size());
		assertTrue("bad clear", content.get(0).equals(text1));
		assertTrue("bad clear", content.get(1).equals(text2));
		assertTrue("bad clear", content.get(2).equals(text3));
		assertTrue("bad clear", content.get(3) == comment);
		assertTrue("bad clear", content.get(4).equals(text4));

		assertTrue("parent is not correct", comment.getParent() == foo);
		assertNull("parent is not correct", bar.getParent());
		assertNull("parent is not correct", baz.getParent());
		assertNull("parent is not correct", quux.getParent());

 		content.clear();

		assertTrue("bad clear", children.size() == 0);
		assertTrue("bad clear", content.size() == 0);

		assertNull("parent is not correct", comment.getParent());
		assertNull("parent is not correct", bar.getParent());
		assertNull("parent is not correct", baz.getParent());
		assertNull("parent is not correct", quux.getParent());

   }

    public void test_TCM__Object_remove_int() {
		List content = foo.getContent();
		List children = foo.getChildren();
		
		// \n, bar, \n, baz, \n, comment, quux, \n
		content.remove(4); // third /n
		children.remove(0); // bar
		content.remove(3); // comment
		content.remove(0); // first /n
		// \n, baz, quux, \n

		assertTrue("bad removal", children.size() == 2);
		assertTrue("bad removal", children.get(0) == baz);
		assertTrue("bad removal", children.get(1) == quux);
		assertTrue("bad removal", content.size() == 4);
		assertTrue("bad removal", content.get(0).equals(text2));
		assertTrue("bad removal", content.get(1) == baz);
		assertTrue("bad removal", content.get(2) == quux);
		assertTrue("bad removal", content.get(3).equals(text4));

		assertNull("parent is not correct", bar.getParent());
		assertTrue("parent is not correct", baz.getParent() == foo);
		assertTrue("parent is not correct", quux.getParent() == foo);
		assertNull("parent is not correct", comment.getParent());

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

    public void test_TCM__boolean_remove_Object() {
		List content = foo.getContent();
		List children = foo.getChildren();
		
		// contents: \n, bar, \n, baz, \n, comment, quux, \n
		assertTrue("bad removal", content.remove(text1));			// first /n
		assertTrue("bad removal", children.remove(bar));			// bar
		assertTrue("bad removal", content.remove(comment));			// comment
		assertTrue("bad removal", content.remove(text2));			// second /n
		// contents: baz, \n, quux, \n

		// None of these should have any effect.
		assertTrue("bad removal", !children.remove(bar));
		assertTrue("bad removal", !children.remove(text2));
		assertTrue("bad removal", !children.remove(comment2));
		assertTrue("bad removal", !children.remove(new Integer(17)));
		assertTrue("bad removal", !content.remove(bar));
		assertTrue("bad removal", !content.remove(comment2));
		assertTrue("bad removal", !content.remove(new Integer(17)));

		assertTrue("bad removal", children.size() == 2);
		assertTrue("bad removal", children.get(0) == baz);
		assertTrue("bad removal", children.get(1) == quux);
		assertTrue("bad removal", content.size() == 4);
		assertTrue("bad removal", content.get(0) == baz);
		assertTrue("bad removal", content.get(1).equals(text3));
		assertTrue("bad removal", content.get(2) == quux);
		assertTrue("bad removal", content.get(3).equals(text4));

		assertNull("parent is not correct", bar.getParent());
		assertTrue("parent is not correct", baz.getParent() == foo);
		assertTrue("parent is not correct", quux.getParent() == foo);
		assertNull("parent is not correct", comment.getParent());
    }

    public void test_TCM__boolean_isEmpty() {
		List children = foo.getChildren();
		int size = children.size();
		for (int i = 0; i < size; i++)
		{
			assertFalse("bad isEmpty", children.isEmpty());
			children.remove(0);
		}

		assertTrue("bad isEmpty", children.isEmpty());
    }

    public void test_TCM__boolean_containsAll_Collection() {
		List content = foo.getContent();
		List contentList = new ArrayList();
		contentList.add(quux);
		contentList.add(baz);
		contentList.add(text3);
		contentList.add(text1);
		contentList.add(text2);
		contentList.add(comment);
		assertTrue("bad containsAll", content.containsAll(contentList));
		contentList.add(bar);
		contentList.add(text4);
		assertTrue("bad containsAll", content.containsAll(contentList));
		contentList.add(comment2);
		assertFalse("bad containsAll", content.containsAll(contentList));

		List children = foo.getChildren();
		List childrenList = new ArrayList();
		childrenList.add(baz);
		assertTrue("bad containsAll", children.containsAll(childrenList));
		childrenList.add(bar);
		childrenList.add(quux);
		assertTrue("bad containsAll", children.containsAll(childrenList));
		childrenList.add(comment);
		assertFalse("bad containsAll", children.containsAll(childrenList));
    }

    public void test_TCM__boolean_addAll_Collection() {
		List content = foo.getContent();
		List addList = new ArrayList();
		addList.add(comment2);
		addList.add(comment3);
		content.addAll(addList);
		assertEquals("bad addAll", 10, content.size());
		assertEquals("bad addAll", text1, content.get(0));
		assertEquals("bad addAll", bar, content.get(1));
		assertEquals("bad addAll", text2, content.get(2));