[201159] model rework - added support for moving list items

5 files changed, 897 insertions, 16 deletions

diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/CollectionToolsTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/CollectionToolsTests.java
index ad7980fbe3..7bd0a7d3f8 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/CollectionToolsTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/CollectionToolsTests.java
@@ -1351,6 +1351,183 @@ public class CollectionToolsTests extends TestCase {
 		assertEquals(0, CollectionTools.min(this.buildIntArray()));
 	}
 
+	public void testMoveObjectArrayIntInt() {
+		String[] array = new String[] { "0", "1", "2", "3", "4", "5" };
+
+		String[] result = CollectionTools.move(array, 4, 2);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "0", "1", "3", "4", "2", "5" }, result));
+
+		result = CollectionTools.move(array, 0, 5);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "1", "3", "4", "2" }, result));
+
+		result = CollectionTools.move(array, 2, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result));
+	}
+
+	public void testMoveObjectArrayIntIntInt() {
+		String[] array = new String[] { "0", "1", "2", "3", "4", "5" };
+
+		String[] result = CollectionTools.move(array, 4, 2, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "0", "1", "3", "4", "2", "5" }, result));
+
+		result = CollectionTools.move(array, 0, 5, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "1", "3", "4", "2" }, result));
+
+		result = CollectionTools.move(array, 2, 4, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result));
+
+		result = CollectionTools.move(array, 2, 4, 2);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result));
+
+		result = CollectionTools.move(array, 0, 1, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "0", "3", "2", "4", "5", "1" }, result));
+
+		result = CollectionTools.move(array, 1, 0, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result));
+	}
+
+	public void testMoveIntArrayIntInt() {
+		int[] array = new int[] { 0, 1, 2, 3, 4, 5 };
+
+		int[] result = CollectionTools.move(array, 4, 2);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 0, 1, 3, 4, 2, 5 }, result));
+
+		result = CollectionTools.move(array, 0, 5);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 5, 0, 1, 3, 4, 2 }, result));
+
+		result = CollectionTools.move(array, 2, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 5, 0, 4, 1, 3, 2 }, result));
+	}
+
+	public void testMoveInttArrayIntIntInt() {
+		int[] array = new int[] { 0, 1, 2, 3, 4, 5 };
+
+		int[] result = CollectionTools.move(array, 4, 2, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 0, 1, 3, 4, 2, 5 }, result));
+
+		result = CollectionTools.move(array, 0, 5, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 5, 0, 1, 3, 4, 2 }, result));
+
+		result = CollectionTools.move(array, 2, 4, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 5, 0, 4, 1, 3, 2 }, result));
+
+		result = CollectionTools.move(array, 2, 4, 2);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 5, 0, 3, 2, 4, 1 }, result));
+
+		result = CollectionTools.move(array, 0, 1, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 0, 3, 2, 4, 5, 1 }, result));
+
+		result = CollectionTools.move(array, 1, 0, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new int[] { 5, 0, 3, 2, 4, 1 }, result));
+	}
+
+	public void testMoveCharArrayIntInt() {
+		char[] array = new char[] { 'a', 'b', 'c', 'd', 'e', 'f' };
+
+		char[] result = CollectionTools.move(array, 4, 2);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'd', 'e', 'c', 'f' }, result));
+
+		result = CollectionTools.move(array, 0, 5);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'f', 'a', 'b', 'd', 'e', 'c' }, result));
+
+		result = CollectionTools.move(array, 2, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'f', 'a', 'e', 'b', 'd', 'c' }, result));
+	}
+
+	public void testMoveCharArrayIntIntInt() {
+		char[] array = new char[] { 'a', 'b', 'b', 'c', 'd', 'e' };
+
+		char[] result = CollectionTools.move(array, 4, 2, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c', 'd', 'b', 'e' }, result));
+
+		result = CollectionTools.move(array, 0, 5, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'b', 'c', 'd', 'b' }, result));
+
+		result = CollectionTools.move(array, 2, 4, 1);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'd', 'b', 'c', 'b' }, result));
+
+		result = CollectionTools.move(array, 2, 4, 2);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'c', 'b', 'd', 'b' }, result));
+
+		result = CollectionTools.move(array, 0, 1, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'a', 'c', 'b', 'd', 'e', 'b' }, result));
+
+		result = CollectionTools.move(array, 1, 0, 4);
+		assertSame(array, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'c', 'b', 'd', 'b' }, result));
+	}
+
+	public void testMoveListIntInt() {
+		List<String> list = new ArrayList<String>();
+		CollectionTools.addAll(list, new String[] { "0", "1", "2", "3", "4", "5" });
+
+		List<String> result = CollectionTools.move(list, 4, 2);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "0", "1", "3", "4", "2", "5" }, result.toArray()));
+
+		result = CollectionTools.move(list, 0, 5);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "1", "3", "4", "2" }, result.toArray()));
+
+		result = CollectionTools.move(list, 2, 4);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result.toArray()));
+	}
+
+	public void testMoveListIntIntInt() {
+		List<String> list = new ArrayList<String>(Arrays.asList(new String[] { "0", "1", "2", "3", "4", "5" }));
+
+		List<String> result = CollectionTools.move(list, 4, 2, 1);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "0", "1", "3", "4", "2", "5" }, result.toArray()));
+
+		result = CollectionTools.move(list, 0, 5, 1);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "1", "3", "4", "2" }, result.toArray()));
+
+		result = CollectionTools.move(list, 2, 4, 1);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result.toArray()));
+
+		result = CollectionTools.move(list, 2, 4, 2);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result.toArray()));
+
+		result = CollectionTools.move(list, 0, 1, 4);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "0", "3", "2", "4", "5", "1" }, result.toArray()));
+
+		result = CollectionTools.move(list, 1, 0, 4);
+		assertSame(list, result);  // the array is modified in place and returned
+		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result.toArray()));
+	}
+
 	public void testRemoveAllObjectArrayObjectArray() {
 		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
 		String[] a2 = new String[] { "E", "B" };
@@ -1665,6 +1842,41 @@ public class CollectionToolsTests extends TestCase {
 
 	public void testRemoveElementAtIndexIntArrayInt() {
 		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
+		a = CollectionTools.removeElementsAtIndex(a, 3, 3);
+		assertTrue(Arrays.equals(new int[] { 8, 6, 7 }, a));
+	}
+
+	public void testRemoveElementsAtIndexListIntInt() {
+		List<String> list = new ArrayList<String>(Arrays.asList(new String[] { "A", "B", "A", "C", "A", "D" }));
+		List<String> removed = CollectionTools.removeElementsAtIndex(list, 3, 2);
+		assertTrue(Arrays.equals(new String[] { "A", "B", "A", "D" }, list.toArray()));
+		assertTrue(Arrays.equals(new String[] { "C", "A" }, removed.toArray()));
+
+		list = new ArrayList<String>(Arrays.asList(new String[] { "A", "B", "C", "D", "E", "F" }));
+		removed = CollectionTools.removeElementsAtIndex(list, 3, 3);
+		assertTrue(Arrays.equals(new String[] { "A", "B", "C" }, list.toArray()));
+		assertTrue(Arrays.equals(new String[] { "D", "E", "F" }, removed.toArray()));
+
+		list = new ArrayList<String>(Arrays.asList(new String[] { "A", "B", "C", "D", "E", "F" }));
+		removed = CollectionTools.removeElementsAtIndex(list, 0, 3);
+		assertTrue(Arrays.equals(new String[] { "D", "E", "F" }, list.toArray()));
+		assertTrue(Arrays.equals(new String[] { "A", "B", "C" }, removed.toArray()));
+	}
+
+	public void testRemoveElementsAtIndexObjectArrayIntInt() {
+		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
+		a = CollectionTools.removeElementsAtIndex(a, 3, 2);
+		assertTrue(Arrays.equals(new String[] { "A", "B", "A", "D" }, a));
+	}
+
+	public void testRemoveElementsAtIndexCharArrayIntInt() {
+		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
+		a = CollectionTools.removeElementsAtIndex(a, 0, 5);
+		assertTrue(Arrays.equals(new char[] { 'D' }, a));
+	}
+
+	public void testRemoveElementsAtIndexIntArrayIntInt() {
+		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
 		a = CollectionTools.removeElementAtIndex(a, 3);
 		assertTrue(Arrays.equals(new int[] { 8, 6, 7, 2, 11 }, a));
 	}
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/AbstractModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/AbstractModelTests.java
index 64ef4a875b..1fd45cf790 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/AbstractModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/AbstractModelTests.java
@@ -50,15 +50,20 @@ public class AbstractModelTests
 	private boolean itemsAddedCollectionCalled = false;
 	private boolean itemsRemovedCollectionCalled = false;
 	private boolean collectionChangedCalled = false;
+	private boolean collectionClearedCalled = false;
 	private static final String COLLECTION_NAME = "collectionName";
 	static final Object ADDED_OBJECT_VALUE = new Object();
 	static final Object REMOVED_OBJECT_VALUE = new Object();
+	static final int TARGET_INDEX = 7;
+	static final int SOURCE_INDEX = 22;
 
 	private ListChangeEvent listChangeEvent;
 	private boolean itemsAddedListCalled = false;
 	private boolean itemsRemovedListCalled = false;
 	private boolean itemsReplacedListCalled = false;
+	private boolean itemsMovedListCalled = false;
 	private boolean listChangedCalled = false;
+	private boolean listClearedCalled = false;
 	private static final String LIST_NAME = "listName";
 	private static final int ADD_INDEX = 3;
 	private static final int REMOVE_INDEX = 5;
@@ -68,8 +73,10 @@ public class AbstractModelTests
 	private boolean nodeAddedCalled = false;
 	private boolean nodeRemovedCalled = false;
 	private boolean treeChangedCalled = false;
+	private boolean treeClearedCalled = false;
 	private static final String TREE_NAME = "treeName";
 	static final Object[] OBJECT_ARRAY_PATH = {new Object(), new Object(), new String()};
+	static final Object[] EMPTY_PATH = {};
 
 	public AbstractModelTests(String name) {
 		super(name);
@@ -277,6 +284,36 @@ public class AbstractModelTests
 		assertFalse(this.itemsRemovedCollectionCalled);
 	}
 
+	public void testFireCollectionCleared() {
+		this.collectionChangeEvent = null;
+		this.collectionClearedCalled = false;
+		this.testModel.addCollectionChangeListener(this);
+		this.testModel.testFireCollectionCleared();
+		this.verifyCollectionChangeEvent(null);
+		assertTrue(this.collectionClearedCalled);
+
+		this.collectionChangeEvent = null;
+		this.collectionClearedCalled = false;
+		this.testModel.removeCollectionChangeListener(this);
+		this.testModel.testFireCollectionCleared();
+		assertNull(this.collectionChangeEvent);
+		assertFalse(this.collectionClearedCalled);
+
+		this.collectionChangeEvent = null;
+		this.collectionClearedCalled = false;
+		this.testModel.addCollectionChangeListener(COLLECTION_NAME, this);
+		this.testModel.testFireCollectionCleared();
+		this.verifyCollectionChangeEvent(null);
+		assertTrue(this.collectionClearedCalled);
+
+		this.collectionChangeEvent = null;
+		this.collectionClearedCalled = false;
+		this.testModel.removeCollectionChangeListener(COLLECTION_NAME, this);
+		this.testModel.testFireCollectionCleared();
+		assertNull(this.collectionChangeEvent);
+		assertFalse(this.collectionClearedCalled);
+	}
+
 	public void testFireCollectionChanged() {
 		this.collectionChangeEvent = null;
 		this.collectionChangedCalled = false;
@@ -397,6 +434,66 @@ public class AbstractModelTests
 		assertFalse(this.itemsReplacedListCalled);
 	}
 
+	public void testFireItemMovedList() {
+		this.listChangeEvent = null;
+		this.itemsMovedListCalled = false;
+		this.testModel.addListChangeListener(this);
+		this.testModel.testFireItemMovedList();
+		this.verifyListChangeEvent(TARGET_INDEX, SOURCE_INDEX);
+		assertTrue(this.itemsMovedListCalled);
+
+		this.listChangeEvent = null;
+		this.itemsMovedListCalled = false;
+		this.testModel.removeListChangeListener(this);
+		this.testModel.testFireItemMovedList();
+		assertNull(this.listChangeEvent);
+		assertFalse(this.itemsMovedListCalled);
+
+		this.listChangeEvent = null;
+		this.itemsMovedListCalled = false;
+		this.testModel.addListChangeListener(LIST_NAME, this);
+		this.testModel.testFireItemMovedList();
+		this.verifyListChangeEvent(TARGET_INDEX, SOURCE_INDEX);
+		assertTrue(this.itemsMovedListCalled);
+
+		this.listChangeEvent = null;
+		this.itemsMovedListCalled = false;
+		this.testModel.removeListChangeListener(LIST_NAME, this);
+		this.testModel.testFireItemMovedList();
+		assertNull(this.listChangeEvent);
+		assertFalse(this.itemsMovedListCalled);
+	}
+
+	public void testFireListCleared() {
+		this.listChangeEvent = null;
+		this.listClearedCalled = false;
+		this.testModel.addListChangeListener(this);
+		this.testModel.testFireListCleared();
+		this.verifyListChangeEvent(-1, null);
+		assertTrue(this.listClearedCalled);
+
+		this.listChangeEvent = null;
+		this.listClearedCalled = false;
+		this.testModel.removeListChangeListener(this);
+		this.testModel.testFireListCleared();
+		assertNull(this.listChangeEvent);
+		assertFalse(this.listClearedCalled);
+
+		this.listChangeEvent = null;
+		this.listClearedCalled = false;
+		this.testModel.addListChangeListener(LIST_NAME, this);
+		this.testModel.testFireListCleared();
+		this.verifyListChangeEvent(-1, null);
+		assertTrue(this.listClearedCalled);
+
+		this.listChangeEvent = null;
+		this.listClearedCalled = false;
+		this.testModel.removeListChangeListener(LIST_NAME, this);
+		this.testModel.testFireListCleared();
+		assertNull(this.listChangeEvent);
+		assertFalse(this.listClearedCalled);
+	}
+
 	public void testFireListChanged() {
 		this.listChangeEvent = null;
 		this.listChangedCalled = false;
@@ -487,32 +584,62 @@ public class AbstractModelTests
 		assertFalse(this.nodeRemovedCalled);
 	}
 
-	public void testFireTreeStructureChangedObjectArrayPath() {
+	public void testFireTreeCleared() {
+		this.treeChangeEvent = null;
+		this.treeClearedCalled = false;
+		this.testModel.addTreeChangeListener(this);
+		this.testModel.testFireTreeCleared();
+		this.verifyTreeChangeEvent(EMPTY_PATH);
+		assertTrue(this.treeClearedCalled);
+
+		this.treeChangeEvent = null;
+		this.treeClearedCalled = false;
+		this.testModel.removeTreeChangeListener(this);
+		this.testModel.testFireTreeCleared();
+		assertNull(this.treeChangeEvent);
+		assertFalse(this.treeClearedCalled);
+
+		this.treeChangeEvent = null;
+		this.treeClearedCalled = false;
+		this.testModel.addTreeChangeListener(TREE_NAME, this);
+		this.testModel.testFireTreeCleared();
+		this.verifyTreeChangeEvent(EMPTY_PATH);
+		assertTrue(this.treeClearedCalled);
+
+		this.treeChangeEvent = null;
+		this.treeClearedCalled = false;
+		this.testModel.removeTreeChangeListener(TREE_NAME, this);
+		this.testModel.testFireTreeCleared();
+		assertNull(this.treeChangeEvent);
+		assertFalse(this.treeClearedCalled);
+	}
+
+	public void testFireTreeChangedObjectArrayPath() {
 		this.treeChangeEvent = null;
 		this.treeChangedCalled = false;
 		this.testModel.addTreeChangeListener(this);
-		this.testModel.testFireTreeStructureChangedObjectArrayPath();
+		this.testModel.testFireTreeChangedObjectArrayPath();
 		this.verifyTreeChangeEvent(OBJECT_ARRAY_PATH);
 		assertTrue(this.treeChangedCalled);
 
 		this.treeChangeEvent = null;
 		this.treeChangedCalled = false;
 		this.testModel.removeTreeChangeListener(this);
-		this.testModel.testFireTreeStructureChangedObjectArrayPath();
+		this.testModel.testFireTreeChangedObjectArrayPath();
 		assertNull(this.treeChangeEvent);
 		assertFalse(this.treeChangedCalled);
 
 		this.treeChangeEvent = null;
 		this.treeChangedCalled = false;
 		this.testModel.addTreeChangeListener(TREE_NAME, this);
-		this.testModel.testFireTreeStructureChangedObjectArrayPath();
+		this.testModel.testFireTreeChangedObjectArrayPath();
 		this.verifyTreeChangeEvent(OBJECT_ARRAY_PATH);
 		assertTrue(this.treeChangedCalled);
 
 		this.treeChangeEvent = null;
 		this.treeChangedCalled = false;
 		this.testModel.removeTreeChangeListener(TREE_NAME, this);
-		this.testModel.testFireTreeStructureChangedObjectArrayPath();
+		this.testModel.testFireTreeChangedObjectArrayPath();
 		assertNull(this.treeChangeEvent);
 		assertFalse(this.treeChangedCalled);
 	}
@@ -966,6 +1093,14 @@ public class AbstractModelTests
 		this.verifyListChangeEvent(index, item, null);
 	}
 
+	private void verifyListChangeEvent(int targetIndex, int sourceIndex) {
+		assertNotNull(this.listChangeEvent);
+		assertEquals(this.testModel, this.listChangeEvent.getSource());
+		assertEquals(LIST_NAME, this.listChangeEvent.listName());
+		assertEquals(targetIndex, this.listChangeEvent.targetIndex());
+		assertEquals(sourceIndex, this.listChangeEvent.sourceIndex());
+	}
+
 	private void verifyListChangeEvent(int index, Object item, Object replacedItem) {
 		assertNotNull(this.listChangeEvent);
 		assertEquals(this.testModel, this.listChangeEvent.getSource());
@@ -1010,6 +1145,10 @@ public class AbstractModelTests
 		this.itemsRemovedCollectionCalled = true;
 		this.collectionChangeEvent = e;
 	}
+	public void collectionCleared(CollectionChangeEvent e) {
+		this.collectionClearedCalled = true;
+		this.collectionChangeEvent = e;
+	}
 	public void collectionChanged(CollectionChangeEvent e) {
 		this.collectionChangedCalled = true;
 		this.collectionChangeEvent = e;
@@ -1027,6 +1166,14 @@ public class AbstractModelTests
 		this.itemsReplacedListCalled = true;
 		this.listChangeEvent = e;
 	}
+	public void itemsMoved(ListChangeEvent e) {
+		this.itemsMovedListCalled = true;
+		this.listChangeEvent = e;
+	}
+	public void listCleared(ListChangeEvent e) {
+		this.listClearedCalled = true;
+		this.listChangeEvent = e;
+	}
 	public void listChanged(ListChangeEvent e) {
 		this.listChangedCalled = true;
 		this.listChangeEvent = e;
@@ -1040,6 +1187,10 @@ public class AbstractModelTests
 		this.nodeRemovedCalled = true;
 		this.treeChangeEvent = e;
 	}
+	public void treeCleared(TreeChangeEvent e) {
+		this.treeClearedCalled = true;
+		this.treeChangeEvent = e;
+	}
 	public void treeChanged(TreeChangeEvent e) {
 		this.treeChangedCalled = true;
 		this.treeChangeEvent = e;
@@ -1080,6 +1231,10 @@ public class AbstractModelTests
 			this.fireItemRemoved(COLLECTION_NAME, REMOVED_OBJECT_VALUE);
 		}
 	
+		public void testFireCollectionCleared() {
+			this.fireCollectionCleared(COLLECTION_NAME);
+		}
+	
 		public void testFireCollectionChanged() {
 			this.fireCollectionChanged(COLLECTION_NAME);
 		}
@@ -1096,6 +1251,14 @@ public class AbstractModelTests
 			this.fireItemReplaced(LIST_NAME, REPLACE_INDEX, ADDED_OBJECT_VALUE, REMOVED_OBJECT_VALUE);
 		}
 	
+		public void testFireItemMovedList() {
+			this.fireItemMoved(LIST_NAME, TARGET_INDEX, SOURCE_INDEX);
+		}
+	
+		public void testFireListCleared() {
+			this.fireListCleared(LIST_NAME);
+		}
+	
 		public void testFireListChanged() {
 			this.fireListChanged(LIST_NAME);
 		}
@@ -1108,8 +1271,12 @@ public class AbstractModelTests
 			this.fireNodeRemoved(TREE_NAME, OBJECT_ARRAY_PATH);
 		}
 	
-		public void testFireTreeStructureChangedObjectArrayPath() {
-			this.fireTreeStructureChanged(TREE_NAME, OBJECT_ARRAY_PATH);
+		public void testFireTreeCleared() {
+			this.fireTreeCleared(TREE_NAME);
+		}
+	
+		public void testFireTreeChangedObjectArrayPath() {
+			this.fireTreeChanged(TREE_NAME, OBJECT_ARRAY_PATH);
 		}
 	
 		public void testAttributeValueHasChanged() {
@@ -1257,7 +1424,7 @@ public class AbstractModelTests
 			this.fireListChanged("foo");
 		}
 		void notifyTreeListeners() {
-			this.fireTreeStructureChanged("foo");
+			this.fireTreeChanged("foo");
 		}
 	}
 
@@ -1289,19 +1456,23 @@ public class AbstractModelTests
 		public void collectionChanged(CollectionChangeEvent e) {
 			this.fireCollectionChanged("bar");
 		}
+		public void collectionCleared(CollectionChangeEvent e) {/*ignore*/}
 		public void itemsAdded(CollectionChangeEvent e) {/*ignore*/}
 		public void itemsRemoved(CollectionChangeEvent e) {/*ignore*/}
 
 		public void listChanged(ListChangeEvent e) {
 			this.fireListChanged("bar");
 		}
+		public void listCleared(ListChangeEvent e) {/*ignore*/}
 		public void itemsAdded(ListChangeEvent e) {/*ignore*/}
 		public void itemsRemoved(ListChangeEvent e) {/*ignore*/}
 		public void itemsReplaced(ListChangeEvent e) {/*ignore*/}
+		public void itemsMoved(ListChangeEvent e) {/*ignore*/}
 
 		public void treeChanged(TreeChangeEvent e) {
-			this.fireTreeStructureChanged("bar");
+			this.fireTreeChanged("bar");
 		}
+		public void treeCleared(TreeChangeEvent e) {/*ignore*/}
 		public void nodeAdded(TreeChangeEvent e) {/*ignore*/}
 		public void nodeRemoved(TreeChangeEvent e) {/*ignore*/}
 
@@ -1386,6 +1557,7 @@ public class AbstractModelTests
 				throw new IllegalStateException("bogus event source: " + source);
 			}
 		}
+		public void collectionCleared(CollectionChangeEvent e) {/*ignore*/}
 		public void itemsAdded(CollectionChangeEvent e) {/*ignore*/}
 		public void itemsRemoved(CollectionChangeEvent e) {/*ignore*/}
 
@@ -1402,9 +1574,11 @@ public class AbstractModelTests
 				throw new IllegalStateException("bogus event source: " + source);
 			}
 		}
+		public void listCleared(ListChangeEvent e) {/*ignore*/}
 		public void itemsAdded(ListChangeEvent e) {/*ignore*/}
 		public void itemsRemoved(ListChangeEvent e) {/*ignore*/}
 		public void itemsReplaced(ListChangeEvent e) {/*ignore*/}
+		public void itemsMoved(ListChangeEvent e) {/*ignore*/}
 
 		public void treeChanged(TreeChangeEvent e) {
 			Object source = e.getSource();
@@ -1419,6 +1593,7 @@ public class AbstractModelTests
 				throw new IllegalStateException("bogus event source: " + source);
 			}
 		}
+		public void treeCleared(TreeChangeEvent e) {/*ignore*/}
 		public void nodeAdded(TreeChangeEvent e) {/*ignore*/}
 		public void nodeRemoved(TreeChangeEvent e) {/*ignore*/}
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveCollectionChangeListenerTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveCollectionChangeListenerTests.java
index a55f0a4b3b..a60f0b52b5 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveCollectionChangeListenerTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveCollectionChangeListenerTests.java
@@ -32,11 +32,11 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 	}
 
 	private CollectionChangeListener buildZeroArgumentListener(Object target) {
-		return ReflectiveChangeListener.buildCollectionChangeListener(target, "itemAddedZeroArgument", "itemRemovedZeroArgument", "collectionChangedZeroArgument");
+		return ReflectiveChangeListener.buildCollectionChangeListener(target, "itemAddedZeroArgument", "itemRemovedZeroArgument", "collectionClearedZeroArgument", "collectionChangedZeroArgument");
 	}
 
 	private CollectionChangeListener buildSingleArgumentListener(Object target) {
-		return ReflectiveChangeListener.buildCollectionChangeListener(target, "itemAddedSingleArgument", "itemRemovedSingleArgument", "collectionChangedSingleArgument");
+		return ReflectiveChangeListener.buildCollectionChangeListener(target, "itemAddedSingleArgument", "itemRemovedSingleArgument", "collectionClearedSingleArgument", "collectionChangedSingleArgument");
 	}
 
 	public void testItemAddedZeroArgument() {
@@ -49,6 +49,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -63,6 +65,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -77,6 +81,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertTrue(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -91,6 +97,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertTrue(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -106,6 +114,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertTrue(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -121,6 +131,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertTrue(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -136,6 +148,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertTrue(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -151,6 +165,76 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertTrue(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
+		assertFalse(target.collectionChangedZeroArgumentFlag);
+		assertFalse(target.collectionChangedSingleArgumentFlag);
+	}
+
+	public void testCollectionClearedZeroArgument() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_COLLECTION, string);
+		testModel.addCollectionChangeListener(this.buildZeroArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertTrue(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
+		assertFalse(target.collectionChangedZeroArgumentFlag);
+		assertFalse(target.collectionChangedSingleArgumentFlag);
+	}
+
+	public void testCollectionClearedZeroArgumentNamedCollection() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_COLLECTION, string);
+		testModel.addCollectionChangeListener(TestModel.STRINGS_COLLECTION, this.buildZeroArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertTrue(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
+		assertFalse(target.collectionChangedZeroArgumentFlag);
+		assertFalse(target.collectionChangedSingleArgumentFlag);
+	}
+
+	public void testCollectionClearedSingleArgument() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_COLLECTION, string);
+		testModel.addCollectionChangeListener(this.buildSingleArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertTrue(target.collectionClearedSingleArgumentFlag);
+		assertFalse(target.collectionChangedZeroArgumentFlag);
+		assertFalse(target.collectionChangedSingleArgumentFlag);
+	}
+
+	public void testCollectionClearedSingleArgumentNamedCollection() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_COLLECTION, string);
+		testModel.addCollectionChangeListener(TestModel.STRINGS_COLLECTION, this.buildSingleArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertTrue(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -166,6 +250,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertTrue(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -181,6 +267,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertTrue(target.collectionChangedZeroArgumentFlag);
 		assertFalse(target.collectionChangedSingleArgumentFlag);
 	}
@@ -196,6 +284,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertTrue(target.collectionChangedSingleArgumentFlag);
 	}
@@ -211,6 +301,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		assertFalse(target.itemAddedSingleArgumentFlag);
 		assertFalse(target.itemRemovedZeroArgumentFlag);
 		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.collectionClearedZeroArgumentFlag);
+		assertFalse(target.collectionClearedSingleArgumentFlag);
 		assertFalse(target.collectionChangedZeroArgumentFlag);
 		assertTrue(target.collectionChangedSingleArgumentFlag);
 	}
@@ -288,6 +380,9 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		void removeString(String string) {
 			this.removeItemFromCollection(string, this.strings, STRINGS_COLLECTION);
 		}
+		void clearStrings() {
+			this.clearCollection(this.strings, STRINGS_COLLECTION);
+		}
 		void replaceStrings(String[] newStrings) {
 			this.strings.clear();
 			CollectionTools.addAll(this.strings, newStrings);
@@ -306,6 +401,8 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 		boolean itemAddedSingleArgumentFlag = false;
 		boolean itemRemovedZeroArgumentFlag = false;
 		boolean itemRemovedSingleArgumentFlag = false;
+		boolean collectionClearedZeroArgumentFlag = false;
+		boolean collectionClearedSingleArgumentFlag = false;
 		boolean collectionChangedZeroArgumentFlag = false;
 		boolean collectionChangedSingleArgumentFlag = false;
 		Target(TestModel testModel, String collectionName, String string) {
@@ -332,6 +429,15 @@ public class ReflectiveCollectionChangeListenerTests extends TestCase {
 			assertEquals(this.collectionName, e.collectionName());
 			assertEquals(this.string, e.items().next());
 		}
+		void collectionClearedZeroArgument() {
+			this.collectionClearedZeroArgumentFlag = true;
+		}
+		void collectionClearedSingleArgument(CollectionChangeEvent e) {
+			this.collectionClearedSingleArgumentFlag = true;
+			assertSame(this.testModel, e.getSource());
+			assertEquals(this.collectionName, e.collectionName());
+			assertFalse(e.items().hasNext());
+		}
 		void collectionChangedZeroArgument() {
 			this.collectionChangedZeroArgumentFlag = true;
 		}
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveListChangeListenerTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveListChangeListenerTests.java
index f5fa819931..ea8b980768 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveListChangeListenerTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveListChangeListenerTests.java
@@ -32,11 +32,11 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 	}
 
 	private ListChangeListener buildZeroArgumentListener(Object target) {
-		return ReflectiveChangeListener.buildListChangeListener(target, "itemAddedZeroArgument", "itemRemovedZeroArgument", "itemReplacedZeroArgument", "listChangedZeroArgument");
+		return ReflectiveChangeListener.buildListChangeListener(target, "itemAddedZeroArgument", "itemRemovedZeroArgument", "itemReplacedZeroArgument", "itemMovedZeroArgument", "listClearedZeroArgument", "listChangedZeroArgument");
 	}
 
 	private ListChangeListener buildSingleArgumentListener(Object target) {
-		return ReflectiveChangeListener.buildListChangeListener(target, "itemAddedSingleArgument", "itemRemovedSingleArgument", "itemReplacedSingleArgument", "listChangedSingleArgument");
+		return ReflectiveChangeListener.buildListChangeListener(target, "itemAddedSingleArgument", "itemRemovedSingleArgument", "itemReplacedSingleArgument", "itemMovedSingleArgument", "listClearedSingleArgument", "listChangedSingleArgument");
 	}
 
 	public void testItemAddedZeroArgument() {
@@ -51,6 +51,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -67,6 +71,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -83,6 +91,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -99,6 +111,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -116,6 +132,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -133,6 +153,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -150,6 +174,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertTrue(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -167,6 +195,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertTrue(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -185,6 +217,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertTrue(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -203,6 +239,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertTrue(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -221,6 +261,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertTrue(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -239,6 +283,186 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertTrue(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testItemMovedZeroArgument() {
+		TestModel testModel = new TestModel();
+		testModel.addString("zero");
+		testModel.addString("one");
+		testModel.addString("two");
+		testModel.addString("three");
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, 0, 2);
+		testModel.addListChangeListener(this.buildZeroArgumentListener(target));
+		testModel.moveString(0, 2);
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertTrue(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testItemMovedZeroArgumentNamedList() {
+		TestModel testModel = new TestModel();
+		testModel.addString("zero");
+		testModel.addString("one");
+		testModel.addString("two");
+		testModel.addString("three");
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, 0, 2);
+		testModel.addListChangeListener(TestModel.STRINGS_LIST, this.buildZeroArgumentListener(target));
+		testModel.moveString(0, 2);
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertTrue(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testItemMovedSingleArgument() {
+		TestModel testModel = new TestModel();
+		testModel.addString("zero");
+		testModel.addString("one");
+		testModel.addString("two");
+		testModel.addString("three");
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, 0, 2);
+		testModel.addListChangeListener(this.buildSingleArgumentListener(target));
+		testModel.moveString(0, 2);
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertTrue(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testItemMovedSingleArgumentNamedList() {
+		TestModel testModel = new TestModel();
+		testModel.addString("zero");
+		testModel.addString("one");
+		testModel.addString("two");
+		testModel.addString("three");
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, 0, 2);
+		testModel.addListChangeListener(TestModel.STRINGS_LIST, this.buildSingleArgumentListener(target));
+		testModel.moveString(0, 2);
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertTrue(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testListClearedZeroArgument() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, null, -1);
+		testModel.addListChangeListener(this.buildZeroArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertTrue(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testListClearedZeroArgumentNamedList() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, null, -1);
+		testModel.addListChangeListener(TestModel.STRINGS_LIST, this.buildZeroArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertTrue(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testListClearedSingleArgument() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, null, -1);
+		testModel.addListChangeListener(this.buildSingleArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertTrue(target.listClearedSingleArgumentFlag);
+		assertFalse(target.listChangedZeroArgumentFlag);
+		assertFalse(target.listChangedSingleArgumentFlag);
+	}
+
+	public void testListClearedSingleArgumentNamedList() {
+		TestModel testModel = new TestModel();
+		String string = "foo";
+		testModel.addString(string);
+		Target target = new Target(testModel, TestModel.STRINGS_LIST, null, -1);
+		testModel.addListChangeListener(TestModel.STRINGS_LIST, this.buildSingleArgumentListener(target));
+		testModel.clearStrings();
+		assertFalse(target.itemAddedZeroArgumentFlag);
+		assertFalse(target.itemAddedSingleArgumentFlag);
+		assertFalse(target.itemRemovedZeroArgumentFlag);
+		assertFalse(target.itemRemovedSingleArgumentFlag);
+		assertFalse(target.itemReplacedZeroArgumentFlag);
+		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertTrue(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -256,6 +480,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertTrue(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -273,6 +501,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertTrue(target.listChangedZeroArgumentFlag);
 		assertFalse(target.listChangedSingleArgumentFlag);
 	}
@@ -290,6 +522,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertTrue(target.listChangedSingleArgumentFlag);
 	}
@@ -307,6 +543,10 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		assertFalse(target.itemRemovedSingleArgumentFlag);
 		assertFalse(target.itemReplacedZeroArgumentFlag);
 		assertFalse(target.itemReplacedSingleArgumentFlag);
+		assertFalse(target.itemMovedZeroArgumentFlag);
+		assertFalse(target.itemMovedSingleArgumentFlag);
+		assertFalse(target.listClearedZeroArgumentFlag);
+		assertFalse(target.listClearedSingleArgumentFlag);
 		assertFalse(target.listChangedZeroArgumentFlag);
 		assertTrue(target.listChangedSingleArgumentFlag);
 	}
@@ -382,6 +622,12 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		void replaceString(String oldString, String newString) {
 			this.setItemInList(this.strings.indexOf(oldString), newString, this.strings, STRINGS_LIST);
 		}
+		void moveString(int targetIndex, int sourceIndex) {
+			this.moveItemInList(targetIndex, sourceIndex, this.strings, STRINGS_LIST);
+		}
+		void clearStrings() {
+			this.clearList(this.strings, STRINGS_LIST);
+		}
 		void replaceAllStrings(String[] newStrings) {
 			this.strings.clear();
 			CollectionTools.addAll(this.strings, newStrings);
@@ -398,12 +644,17 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 		String string;
 		int index;
 		String replacedString;
+		int sourceIndex;
 		boolean itemAddedZeroArgumentFlag = false;
 		boolean itemAddedSingleArgumentFlag = false;
 		boolean itemRemovedZeroArgumentFlag = false;
 		boolean itemRemovedSingleArgumentFlag = false;
 		boolean itemReplacedZeroArgumentFlag = false;
 		boolean itemReplacedSingleArgumentFlag = false;
+		boolean itemMovedZeroArgumentFlag = false;
+		boolean itemMovedSingleArgumentFlag = false;
+		boolean listClearedZeroArgumentFlag = false;
+		boolean listClearedSingleArgumentFlag = false;
 		boolean listChangedZeroArgumentFlag = false;
 		boolean listChangedSingleArgumentFlag = false;
 		Target(TestModel testModel, String listName, String string, int index) {
@@ -417,6 +668,13 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 			this(testModel, listName, string, index);
 			this.replacedString = replacedString;
 		}
+		Target(TestModel testModel, String listName, int targetIndex, int sourceIndex) {
+			super();
+			this.testModel = testModel;
+			this.listName = listName;
+			this.index = targetIndex;
+			this.sourceIndex = sourceIndex;
+		}
 		void itemAddedZeroArgument() {
 			this.itemAddedZeroArgumentFlag = true;
 		}
@@ -448,9 +706,29 @@ public class ReflectiveListChangeListenerTests extends TestCase {
 			assertEquals(this.replacedString, e.replacedItems().next());
 			assertEquals(this.index, e.index());
 		}
+		void itemMovedZeroArgument() {
+			this.itemMovedZeroArgumentFlag = true;
+		}
+		void itemMovedSingleArgument(ListChangeEvent e) {
+			this.itemMovedSingleArgumentFlag = true;
+			assertSame(this.testModel, e.getSource());
+			assertEquals(this.listName, e.listName());
+			assertEquals(this.index, e.targetIndex());
+			assertEquals(this.sourceIndex, e.sourceIndex());
+		}
 		void listChangedZeroArgument() {
 			this.listChangedZeroArgumentFlag = true;
 		}
+		void listClearedSingleArgument(ListChangeEvent e) {
+			this.listClearedSingleArgumentFlag = true;
+			assertSame(this.testModel, e.getSource());
+			assertEquals(this.listName, e.listName());
+			assertFalse(e.items().hasNext());
+			assertEquals(this.index, e.index());
+		}
+		void listClearedZeroArgument() {
+			this.listClearedZeroArgumentFlag = true;
+		}
 		void listChangedSingleArgument(ListChangeEvent e) {
 			this.listChangedSingleArgumentFlag = true;
 			assertSame(this.testModel, e.getSource());
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveTreeChangeListenerTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveTreeChangeListenerTests.java
index 54155bfec1..3798d25494 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveTreeChangeListenerTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/listener/ReflectiveTreeChangeListenerTests.java
@@ -36,11 +36,11 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 	}
 
 	private TreeChangeListener buildZeroArgumentListener(Object target) {
-		return ReflectiveChangeListener.buildTreeChangeListener(target, "nodeAddedZeroArgument", "nodeRemovedZeroArgument", "treeChangedZeroArgument");
+		return ReflectiveChangeListener.buildTreeChangeListener(target, "nodeAddedZeroArgument", "nodeRemovedZeroArgument", "treeClearedZeroArgument", "treeChangedZeroArgument");
 	}
 
 	private TreeChangeListener buildSingleArgumentListener(Object target) {
-		return ReflectiveChangeListener.buildTreeChangeListener(target, "nodeAddedSingleArgument", "nodeRemovedSingleArgument", "treeChangedSingleArgument");
+		return ReflectiveChangeListener.buildTreeChangeListener(target, "nodeAddedSingleArgument", "nodeRemovedSingleArgument", "treeClearedSingleArgument", "treeChangedSingleArgument");
 	}
 
 	public void testNodeAddedZeroArgument() {
@@ -52,6 +52,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -65,6 +67,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -78,6 +82,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertTrue(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -91,6 +97,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertTrue(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -105,6 +113,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertTrue(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -119,6 +129,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertTrue(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -133,6 +145,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertTrue(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -147,6 +161,76 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertTrue(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
+		assertFalse(target.treeChangedZeroArgumentFlag);
+		assertFalse(target.treeChangedSingleArgumentFlag);
+	}
+
+	public void testTreeClearedZeroArgument() {
+		TestModel testModel = new TestModel("root");
+		testModel.addNode("root", "child");
+		testModel.addNode("child", "grandchild");
+		Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[0]);
+		testModel.addTreeChangeListener(this.buildZeroArgumentListener(target));
+		testModel.clearTree();
+		assertFalse(target.nodeAddedZeroArgumentFlag);
+		assertFalse(target.nodeAddedSingleArgumentFlag);
+		assertFalse(target.nodeRemovedZeroArgumentFlag);
+		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertTrue(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
+		assertFalse(target.treeChangedZeroArgumentFlag);
+		assertFalse(target.treeChangedSingleArgumentFlag);
+	}
+
+	public void testTreeClearedZeroArgumentNamedTree() {
+		TestModel testModel = new TestModel("root");
+		testModel.addNode("root", "child");
+		testModel.addNode("child", "grandchild");
+		Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[0]);
+		testModel.addTreeChangeListener(TestModel.STRINGS_TREE, this.buildZeroArgumentListener(target));
+		testModel.clearTree();
+		assertFalse(target.nodeAddedZeroArgumentFlag);
+		assertFalse(target.nodeAddedSingleArgumentFlag);
+		assertFalse(target.nodeRemovedZeroArgumentFlag);
+		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertTrue(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
+		assertFalse(target.treeChangedZeroArgumentFlag);
+		assertFalse(target.treeChangedSingleArgumentFlag);
+	}
+
+	public void testTreeClearedSingleArgument() {
+		TestModel testModel = new TestModel("root");
+		testModel.addNode("root", "child");
+		testModel.addNode("child", "grandchild");
+		Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[0]);
+		testModel.addTreeChangeListener(this.buildSingleArgumentListener(target));
+		testModel.clearTree();
+		assertFalse(target.nodeAddedZeroArgumentFlag);
+		assertFalse(target.nodeAddedSingleArgumentFlag);
+		assertFalse(target.nodeRemovedZeroArgumentFlag);
+		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertTrue(target.treeClearedSingleArgumentFlag);
+		assertFalse(target.treeChangedZeroArgumentFlag);
+		assertFalse(target.treeChangedSingleArgumentFlag);
+	}
+
+	public void testTreeClearedSingleArgumentNamedTree() {
+		TestModel testModel = new TestModel("root");
+		testModel.addNode("root", "child");
+		testModel.addNode("child", "grandchild");
+		Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[0]);
+		testModel.addTreeChangeListener(TestModel.STRINGS_TREE, this.buildSingleArgumentListener(target));
+		testModel.clearTree();
+		assertFalse(target.nodeAddedZeroArgumentFlag);
+		assertFalse(target.nodeAddedSingleArgumentFlag);
+		assertFalse(target.nodeRemovedZeroArgumentFlag);
+		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertTrue(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -161,6 +245,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertTrue(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -175,6 +261,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertTrue(target.treeChangedZeroArgumentFlag);
 		assertFalse(target.treeChangedSingleArgumentFlag);
 	}
@@ -189,6 +277,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertTrue(target.treeChangedSingleArgumentFlag);
 	}
@@ -203,6 +293,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		assertFalse(target.nodeAddedSingleArgumentFlag);
 		assertFalse(target.nodeRemovedZeroArgumentFlag);
 		assertFalse(target.nodeRemovedSingleArgumentFlag);
+		assertFalse(target.treeClearedZeroArgumentFlag);
+		assertFalse(target.treeClearedSingleArgumentFlag);
 		assertFalse(target.treeChangedZeroArgumentFlag);
 		assertTrue(target.treeChangedSingleArgumentFlag);
 	}
@@ -347,7 +439,14 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 			String parent = this.parents.remove(oldNode);
 			this.parents.put(newNode, parent);
 
-			this.fireTreeStructureChanged(STRINGS_TREE, this.path(newNode));
+			this.fireTreeChanged(STRINGS_TREE, this.path(newNode));
+		}
+		void clearTree() {
+			this.childrenLists.clear();
+			this.childrenLists.put(root, new ArrayList<String>());
+			this.parents.clear();
+			this.parents.put(root, null);
+			this.fireTreeCleared(STRINGS_TREE);
 		}
 		void changeCollection() {
 			this.fireCollectionChanged("bogus collection");
@@ -362,6 +461,8 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 		boolean nodeAddedSingleArgumentFlag = false;
 		boolean nodeRemovedZeroArgumentFlag = false;
 		boolean nodeRemovedSingleArgumentFlag = false;
+		boolean treeClearedZeroArgumentFlag = false;
+		boolean treeClearedSingleArgumentFlag = false;
 		boolean treeChangedZeroArgumentFlag = false;
 		boolean treeChangedSingleArgumentFlag = false;
 		Target(TestModel testModel, String treeName, String[] path) {
@@ -388,6 +489,15 @@ public class ReflectiveTreeChangeListenerTests extends TestCase {
 			assertEquals(this.treeName, e.treeName());
 			assertTrue(Arrays.equals(this.path, e.path()));
 		}
+		void treeClearedZeroArgument() {
+			this.treeClearedZeroArgumentFlag = true;
+		}
+		void treeClearedSingleArgument(TreeChangeEvent e) {
+			this.treeClearedSingleArgumentFlag = true;
+			assertSame(this.testModel, e.getSource());
+			assertEquals(this.treeName, e.treeName());
+			assertTrue(Arrays.equals(this.path, e.path()));
+		}
 		void treeChangedZeroArgument() {
 			this.treeChangedZeroArgumentFlag = true;
 		}