[201159] model rework: ListValueModel

28 files changed, 489 insertions, 487 deletions

diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionAspectAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionAspectAdapterTests.java
index 829c588511..34763968bd 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionAspectAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionAspectAdapterTests.java
@@ -190,7 +190,7 @@ public class CollectionAspectAdapterTests extends TestCase {
 		assertEquals(this.subject1Names(), CollectionTools.bag((Iterator) this.aa1.values()));
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		assertEquals(this.subject1Names(), CollectionTools.bag((Iterator) this.aa1.values()));
 		assertNull(this.event1);
 
@@ -216,7 +216,7 @@ public class CollectionAspectAdapterTests extends TestCase {
 		assertEquals(namesPlus, CollectionTools.bag((Iterator) this.aa1.values()));
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		assertEquals(this.subject1Names(), CollectionTools.bag((Iterator) this.aa1.values()));
 		assertNull(this.event1);
 
@@ -258,7 +258,7 @@ public class CollectionAspectAdapterTests extends TestCase {
 		assertEquals(namesPlus2, CollectionTools.bag((Iterator) this.aa1.values()));
 	}
 
-	public void testValue() {
+	public void testValues() {
 		assertEquals(this.subject1Names(), CollectionTools.bag(this.subject1.names()));
 		assertEquals(this.subject1Names(), CollectionTools.bag((Iterator) this.aa1.values()));
 	}
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionListValueModelAdapterTests.java
index a9f97c9266..b576d58308 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionListValueModelAdapterTests.java
@@ -54,14 +54,14 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+	public void testValues() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 		});
 		this.wrappedCollectionHolder.add("foo");
 		this.wrappedCollectionHolder.add("bar");
 		this.wrappedCollectionHolder.add("baz");
-		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		assertEquals(this.wrappedCollection, adapterCollection);
 	}
@@ -70,26 +70,26 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 		ListChangeListener listener = new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 		};
-		this.adapter.addListChangeListener(ValueModel.VALUE, listener);
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, listener);
 		this.wrappedCollectionHolder.add("foo");
 		this.wrappedCollectionHolder.add("bar");
 		this.wrappedCollectionHolder.add("baz");
-		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		assertEquals(this.wrappedCollection, adapterCollection);
 
-		this.adapter.removeListChangeListener(ValueModel.VALUE, listener);
-		adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		this.adapter.removeListChangeListener(ListValueModel.LIST_VALUES, listener);
+		adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(0, adapterCollection.size());
 		assertEquals(new HashBag(), adapterCollection);
 
-		this.adapter.addListChangeListener(ValueModel.VALUE, listener);
-		adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, listener);
+		adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		assertEquals(this.wrappedCollection, adapterCollection);
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		List synchList = new SynchronizedList(this.adapter);
 		Bag synchCollection = new SynchronizedBag(this.wrappedCollectionHolder);
 		this.wrappedCollectionHolder.add("foo");
@@ -101,13 +101,13 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 		this.wrappedCollectionHolder.add("jaz");
 		assertEquals(6, this.wrappedCollection.size());
 
-		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(this.wrappedCollection, adapterCollection);
 		assertEquals(this.wrappedCollection, CollectionTools.collection(synchList.iterator()));
 		assertEquals(this.wrappedCollection, synchCollection);
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		List synchList = new SynchronizedList(this.adapter);
 		Bag synchCollection = new SynchronizedBag(this.wrappedCollectionHolder);
 		this.wrappedCollectionHolder.add("foo");
@@ -122,14 +122,14 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 		assertFalse(this.wrappedCollection.contains("foo"));
 		assertEquals(4, this.wrappedCollection.size());
 
-		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(this.wrappedCollection, adapterCollection);
 		assertEquals(this.wrappedCollection, CollectionTools.collection(synchList.iterator()));
 		assertEquals(this.wrappedCollection, synchCollection);
 	}
 
 	public void testListSynch() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 			public void itemsRemoved(ListChangeEvent e) {/* OK */}
 		});
@@ -145,24 +145,24 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 		assertFalse(this.wrappedCollection.contains("foo"));
 		assertEquals(4, this.wrappedCollection.size());
 
-		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.value());
+		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(this.wrappedCollection, adapterCollection);
 	}
 
 	public void testHasListeners() {
-		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		SynchronizedList synchList = new SynchronizedList(this.adapter);
-		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
-		this.adapter.removeListChangeListener(ValueModel.VALUE, synchList);
-		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
+		this.adapter.removeListChangeListener(ListValueModel.LIST_VALUES, synchList);
+		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.adapter.addListChangeListener(synchList);
-		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.adapter.removeListChangeListener(synchList);
-		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	public void testCollectionChangedToEmpty() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 			public void itemsRemoved(ListChangeEvent e) {/* OK */}
 		});
@@ -175,7 +175,7 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 	}
 	
 	public void testCollectionChangedFromEmpty() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 			public void itemsRemoved(ListChangeEvent e) {/* OK */}
 		});
@@ -189,7 +189,7 @@ public class CollectionListValueModelAdapterTests extends TestCase {
 	}
 	
 	public void testCollectionChangedFromEmptyToEmpty() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 			public void itemsRemoved(ListChangeEvent e) {/* OK */}
 		});
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionPropertyValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionPropertyValueModelAdapterTests.java
index 4bb6c6b0e3..e50c89fce9 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionPropertyValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/CollectionPropertyValueModelAdapterTests.java
@@ -56,7 +56,7 @@ public class CollectionPropertyValueModelAdapterTests extends TestCase {
 		return CollectionTools.collection((Iterator) this.wrappedCollectionHolder.values());
 	}
 
-	public void testGetValue() {
+	public void testValue() {
 		this.adapter.addPropertyChangeListener(ValueModel.VALUE, new PropertyChangeListener() {
 			public void propertyChanged(PropertyChangeEvent e) {/* OK */}
 		});
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ExtendedListValueModelWrapperTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ExtendedListValueModelWrapperTests.java
index cf0f34b9ed..c211b2a1ae 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ExtendedListValueModelWrapperTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ExtendedListValueModelWrapperTests.java
@@ -93,27 +93,27 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
-		assertEquals(this.buildExtendedList(), CollectionTools.list((Iterator) this.extendedListHolder.value()));
+	public void testValues() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
+		assertEquals(this.buildExtendedList(), CollectionTools.list((Iterator) this.extendedListHolder.values()));
 	}
 
 	public void testSize() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
-		assertEquals(this.buildExtendedList().size(), CollectionTools.size((Iterator) this.extendedListHolder.value()));
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
+		assertEquals(this.buildExtendedList().size(), CollectionTools.size((Iterator) this.extendedListHolder.values()));
 		assertEquals(this.buildExtendedList().size(), this.extendedListHolder.size());
 	}
 
 	private boolean extendedListContains(Object item) {
-		return CollectionTools.contains((Iterator) this.extendedListHolder.value(), item);
+		return CollectionTools.contains((Iterator) this.extendedListHolder.values(), item);
 	}
 
 	private boolean extendedListContainsAll(Collection items) {
-		return CollectionTools.containsAll((Iterator) this.extendedListHolder.value(), items);
+		return CollectionTools.containsAll((Iterator) this.extendedListHolder.values(), items);
 	}
 
 	private boolean extendedListContainsAny(Collection items) {
-		List extendedList = CollectionTools.list((ListIterator) this.extendedListHolder.value());
+		List extendedList = CollectionTools.list((ListIterator) this.extendedListHolder.values());
 		for (Iterator stream = items.iterator(); stream.hasNext(); ) {
 			if (extendedList.contains(stream.next())) {
 				return true;
@@ -123,15 +123,15 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 	}
 
 	private boolean listContains(Object item) {
-		return CollectionTools.contains((Iterator) this.listHolder.value(), item);
+		return CollectionTools.contains((Iterator) this.listHolder.values(), item);
 	}
 
 	private boolean listContainsAll(Collection items) {
-		return CollectionTools.containsAll((Iterator) this.listHolder.value(), items);
+		return CollectionTools.containsAll((Iterator) this.listHolder.values(), items);
 	}
 
 	private boolean listContainsAny(Collection items) {
-		List extendedList = CollectionTools.list((ListIterator) this.listHolder.value());
+		List extendedList = CollectionTools.list((ListIterator) this.listHolder.values());
 		for (Iterator stream = items.iterator(); stream.hasNext(); ) {
 			if (extendedList.contains(stream.next())) {
 				return true;
@@ -140,39 +140,39 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		return false;
 	}
 
-	public void testAddItem1() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAdd1() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.extendedListContains("E"));
-		this.listHolder.addItem(4, "E");
+		this.listHolder.add(4, "E");
 		assertTrue(this.extendedListContains("E"));
 		assertTrue(this.listContains("E"));
 	}
 
-	public void testAddItem2() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAdd2() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.extendedListContains(null));
-		this.listHolder.addItem(4, null);
+		this.listHolder.add(4, null);
 		assertTrue(this.extendedListContains(null));
 		assertTrue(this.listContains(null));
 	}
 
-	public void testAddItem3() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAdd3() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.extendedListContains("E"));
-		this.extendedListHolder.addItem(7, "E");
+		this.extendedListHolder.add(7, "E");
 		assertTrue(this.extendedListContains("E"));
 		assertTrue(this.listContains("E"));
 	}
 
-	public void testAddItem4() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAdd4() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.addItem(0, "Z");
+			this.extendedListHolder.add(0, "Z");
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("prefix") != -1) {
 				exCaught = true;
@@ -183,12 +183,12 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		assertFalse(this.listContains("Z"));
 	}
 
-	public void testAddItem5() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAdd5() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.addItem(8, "Z");
+			this.extendedListHolder.add(8, "Z");
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("suffix") != -1) {
 				exCaught = true;
@@ -206,30 +206,30 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		return addList;
 	}
 
-	public void testAddItems1() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAddAll1() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.extendedListContainsAny(this.buildAddList()));
-		this.listHolder.addItems(4, this.buildAddList());
+		this.listHolder.addAll(4, this.buildAddList());
 		assertTrue(this.extendedListContainsAll(this.buildAddList()));
 		assertTrue(this.listContainsAll(this.buildAddList()));
 	}
 
-	public void testAddItems2() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAddAll2() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.extendedListContainsAny(this.buildAddList()));
-		this.extendedListHolder.addItems(4, this.buildAddList());
+		this.extendedListHolder.addAll(4, this.buildAddList());
 		assertTrue(this.extendedListContainsAll(this.buildAddList()));
 		assertTrue(this.listContainsAll(this.buildAddList()));
 	}
 
-	public void testAddItems3() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAddAll3() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.addItems(0, this.buildAddList());
+			this.extendedListHolder.addAll(0, this.buildAddList());
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("prefix") != -1) {
 				exCaught = true;
@@ -240,12 +240,12 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		assertFalse(this.listContainsAny(this.buildAddList()));
 	}
 
-	public void testAddItems4() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAddAll4() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.addItem(8, this.buildAddList());
+			this.extendedListHolder.add(8, this.buildAddList());
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("suffix") != -1) {
 				exCaught = true;
@@ -256,41 +256,41 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		assertFalse(this.listContainsAny(this.buildAddList()));
 	}
 
-	public void testRemoveItem1() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemove1() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("B"));
-		this.listHolder.removeItem(this.buildList().indexOf("B"));
+		this.listHolder.remove(this.buildList().indexOf("B"));
 		assertFalse(this.extendedListContains("B"));
 		assertFalse(this.listContains("B"));
 	}
 
-	public void testRemoveItem2() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemove2() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("B"));
-		this.extendedListHolder.removeItem(this.buildPrefix().size() + this.buildList().indexOf("B"));
+		this.extendedListHolder.remove(this.buildPrefix().size() + this.buildList().indexOf("B"));
 		assertFalse(this.extendedListContains("B"));
 		assertFalse(this.listContains("B"));
 	}
 
-	public void testRemoveItem3() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemove3() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
-		this.listHolder.addItem(0, null);
+		this.listHolder.add(0, null);
 		assertTrue(this.extendedListContains(null));
-		this.extendedListHolder.removeItem(this.buildPrefix().size());
+		this.extendedListHolder.remove(this.buildPrefix().size());
 		assertFalse(this.extendedListContains(null));
 		assertFalse(this.listContains(null));
 	}
 
-	public void testRemoveItem4() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemove4() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("x"));
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.removeItem(CollectionTools.indexOf((ListIterator) this.extendedListHolder.value(), "x"));
+			this.extendedListHolder.remove(CollectionTools.indexOf((ListIterator) this.extendedListHolder.values(), "x"));
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("prefix") != -1) {
 				exCaught = true;
@@ -300,13 +300,13 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		assertTrue(this.extendedListContains("x"));
 	}
 
-	public void testRemoveItem5() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemove5() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("i"));
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.removeItem(CollectionTools.indexOf((ListIterator) this.extendedListHolder.value(), "i"));
+			this.extendedListHolder.remove(CollectionTools.indexOf((ListIterator) this.extendedListHolder.values(), "i"));
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("suffix") != -1) {
 				exCaught = true;
@@ -316,38 +316,38 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		assertTrue(this.extendedListContains("i"));
 	}
 
-	public void testRemoveItems1() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemoveLength1() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("B"));
 		assertTrue(this.extendedListContains("C"));
-		this.listHolder.removeItems(this.buildList().indexOf("B"), 2);
+		this.listHolder.remove(this.buildList().indexOf("B"), 2);
 		assertFalse(this.extendedListContains("B"));
 		assertFalse(this.extendedListContains("C"));
 		assertFalse(this.listContains("B"));
 		assertFalse(this.listContains("C"));
 	}
 
-	public void testRemoveItems2() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemoveLength2() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("B"));
 		assertTrue(this.extendedListContains("C"));
-		this.extendedListHolder.removeItems(this.buildPrefix().size() + this.buildList().indexOf("B"), 2);
+		this.extendedListHolder.remove(this.buildPrefix().size() + this.buildList().indexOf("B"), 2);
 		assertFalse(this.extendedListContains("B"));
 		assertFalse(this.extendedListContains("C"));
 		assertFalse(this.listContains("B"));
 		assertFalse(this.listContains("C"));
 	}
 
-	public void testRemoveItems3() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemoveLength3() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("x"));
 		assertTrue(this.extendedListContains("y"));
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.removeItems(CollectionTools.indexOf((ListIterator) this.extendedListHolder.value(), "x"), 2);
+			this.extendedListHolder.remove(CollectionTools.indexOf((ListIterator) this.extendedListHolder.values(), "x"), 2);
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("prefix") != -1) {
 				exCaught = true;
@@ -358,14 +358,14 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		assertTrue(this.extendedListContains("y"));
 	}
 
-	public void testRemoveItems4() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemoveLength4() {
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.extendedListContains("D"));
 		assertTrue(this.extendedListContains("i"));
 		boolean exCaught = false;
 		try {
-			this.extendedListHolder.removeItems(CollectionTools.indexOf((ListIterator) this.extendedListHolder.value(), "D"), 2);
+			this.extendedListHolder.remove(CollectionTools.indexOf((ListIterator) this.extendedListHolder.values(), "D"), 2);
 		} catch (IllegalArgumentException ex) {
 			if (ex.getMessage().indexOf("suffix") != -1) {
 				exCaught = true;
@@ -382,40 +382,40 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 	}
 
 	public void testListChangeNamed() {
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 		this.verifyListChange();
 	}
 
 	private void verifyListChange() {
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItem(4, "E");
+		this.listHolder.add(4, "E");
 		this.verifyEvent(ADD, 7, "E");
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItem(5, null);
+		this.listHolder.add(5, null);
 		this.verifyEvent(ADD, 8, null);
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.removeItem(5);
+		this.listHolder.remove(5);
 		this.verifyEvent(REMOVE, 8, null);
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.removeItem(4);
+		this.listHolder.remove(4);
 		this.verifyEvent(REMOVE, 7, "E");
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItems(0, this.buildList());
+		this.listHolder.addAll(0, this.buildList());
 		this.verifyEvent(ADD);
 		assertEquals(this.buildList(), CollectionTools.list(this.event.items()));
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.replaceItem(0, "AA");
+		this.listHolder.replace(0, "AA");
 		this.verifyEvent(REPLACE);
 		assertFalse(CollectionTools.contains(this.event.items(), "A"));
 		assertTrue(CollectionTools.contains(this.event.items(), "AA"));
@@ -453,7 +453,7 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 	private void verifyEvent(String type) {
 		assertEquals(type, this.eventType);
 		assertEquals(this.extendedListHolder, this.event.getSource());
-		assertEquals(ValueModel.VALUE, this.event.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event.listName());
 	}
 
 	private void verifyEvent(String type, int index, Object item) {
@@ -469,21 +469,21 @@ public class ExtendedListValueModelWrapperTests extends TestCase {
 		 * likewise, removing listeners from the extended list will
 		 * cause listeners to be removed from the wrapped list
 		 */
-		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		ListChangeListener listener = this.buildListener();
 
-		this.extendedListHolder.addListChangeListener(ValueModel.VALUE, listener);
-		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		this.extendedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, listener);
+		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
-		this.extendedListHolder.removeListChangeListener(ValueModel.VALUE, listener);
-		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		this.extendedListHolder.removeListChangeListener(ListValueModel.LIST_VALUES, listener);
+		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		this.extendedListHolder.addListChangeListener(listener);
-		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		this.extendedListHolder.removeListChangeListener(listener);
-		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 }
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/FilteringCollectionValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/FilteringCollectionValueModelTests.java
index 94a611523b..3d7e87c383 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/FilteringCollectionValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/FilteringCollectionValueModelTests.java
@@ -67,7 +67,7 @@ public class FilteringCollectionValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
+	public void testValues() {
 		// add a listener to "activate" the wrapper
 		this.filteredCollectionHolder.addCollectionChangeListener(CollectionValueModel.VALUES, this.buildFilteredListener());
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemCollectionListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemCollectionListValueModelAdapterTests.java
index afa7995e34..cb82711de9 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemCollectionListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemCollectionListValueModelAdapterTests.java
@@ -94,15 +94,15 @@ public class ItemCollectionListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.addItem(6, this.tom);
-		listHolder.addItem(7, this.dick);
-		listHolder.addItem(8, this.harry);
+		listHolder.add(6, this.tom);
+		listHolder.add(7, this.dick);
+		listHolder.add(8, this.harry);
 		assertEquals(9, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(0);
-		listHolder.removeItem(4);
+		listHolder.remove(8);
+		listHolder.remove(0);
+		listHolder.remove(4);
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 	}
@@ -110,31 +110,31 @@ public class ItemCollectionListValueModelAdapterTests extends TestCase {
 	private void compare(ListValueModel listValueModel, List list) {
 		assertEquals(listValueModel.size(), list.size());
 		for (int i = 0; i < listValueModel.size(); i++) {
-			assertEquals(listValueModel.getItem(i), list.get(i));
+			assertEquals(listValueModel.get(i), list.get(i));
 		}
 	}
 
 
 	public void testHasListeners() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyListChangeListeners(Junk.STUFF_COLLECTION));
 		assertFalse(this.jaz.hasAnyListChangeListeners(Junk.STUFF_COLLECTION));
 
 		ListValueModel listValueModel = new ItemCollectionListValueModelAdapter(listHolder, Junk.STUFF_COLLECTION);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyCollectionChangeListeners(Junk.STUFF_COLLECTION));
 		assertFalse(this.jaz.hasAnyCollectionChangeListeners(Junk.STUFF_COLLECTION));
 		this.verifyHasNoListeners(listValueModel);
 
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
-		assertTrue(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.foo.hasAnyCollectionChangeListeners(Junk.STUFF_COLLECTION));
 		assertTrue(this.jaz.hasAnyCollectionChangeListeners(Junk.STUFF_COLLECTION));
 		this.verifyHasListeners(listValueModel);
 
-		listValueModel.removeListChangeListener(ValueModel.VALUE, synchList);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		listValueModel.removeListChangeListener(ListValueModel.LIST_VALUES, synchList);
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyCollectionChangeListeners(Junk.STUFF_COLLECTION));
 		assertFalse(this.jaz.hasAnyCollectionChangeListeners(Junk.STUFF_COLLECTION));
 		this.verifyHasNoListeners(listValueModel);
@@ -149,27 +149,27 @@ public class ItemCollectionListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 	}
 
-	public void testGetElementAt() throws Exception {
+	public void testGet() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
 		ListValueModel listValueModel = new SortedListValueModelAdapter(new ItemCollectionListValueModelAdapter(listHolder, Junk.STUFF_COLLECTION));
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
 		this.verifyHasListeners(listValueModel);
-		assertEquals(this.bar, listValueModel.getItem(0));
+		assertEquals(this.bar, listValueModel.get(0));
 		assertEquals(this.bar, synchList.get(0));
 		this.bar.removeStuff("bar");
 		this.bar.addStuff("zzz");
 		this.bar.addStuff("bar");
-		assertEquals(this.bar, listValueModel.getItem(5));
+		assertEquals(this.bar, listValueModel.get(5));
 		assertEquals(this.bar, synchList.get(5));
 		this.bar.removeStuff("zzz");
 	}
 
 	private void verifyHasNoListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private void verifyHasListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private CollectionValueModel buildCollectionHolder() {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemListListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemListListValueModelAdapterTests.java
index c0e2434e9a..de8ea7e2ab 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemListListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemListListValueModelAdapterTests.java
@@ -94,15 +94,15 @@ public class ItemListListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.addItem(6, this.tom);
-		listHolder.addItem(7, this.dick);
-		listHolder.addItem(8, this.harry);
+		listHolder.add(6, this.tom);
+		listHolder.add(7, this.dick);
+		listHolder.add(8, this.harry);
 		assertEquals(9, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(0);
-		listHolder.removeItem(4);
+		listHolder.remove(8);
+		listHolder.remove(0);
+		listHolder.remove(4);
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 	}
@@ -110,31 +110,31 @@ public class ItemListListValueModelAdapterTests extends TestCase {
 	private void compare(ListValueModel listValueModel, List list) {
 		assertEquals(listValueModel.size(), list.size());
 		for (int i = 0; i < listValueModel.size(); i++) {
-			assertEquals(listValueModel.getItem(i), list.get(i));
+			assertEquals(listValueModel.get(i), list.get(i));
 		}
 	}
 
 
 	public void testHasListeners() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		assertFalse(this.jaz.hasAnyListChangeListeners(Junk.STUFF_LIST));
 
 		ListValueModel listValueModel = new ItemListListValueModelAdapter(listHolder, Junk.STUFF_LIST);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		assertFalse(this.jaz.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		this.verifyHasNoListeners(listValueModel);
 
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
-		assertTrue(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.foo.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		assertTrue(this.jaz.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		this.verifyHasListeners(listValueModel);
 
-		listValueModel.removeListChangeListener(ValueModel.VALUE, synchList);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		listValueModel.removeListChangeListener(ListValueModel.LIST_VALUES, synchList);
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		assertFalse(this.jaz.hasAnyListChangeListeners(Junk.STUFF_LIST));
 		this.verifyHasNoListeners(listValueModel);
@@ -149,27 +149,27 @@ public class ItemListListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 	}
 
-	public void testGetElementAt() throws Exception {
+	public void testGet() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
 		ListValueModel listValueModel = new SortedListValueModelAdapter(new ItemListListValueModelAdapter(listHolder, Junk.STUFF_LIST));
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
 		this.verifyHasListeners(listValueModel);
-		assertEquals(this.bar, listValueModel.getItem(0));
+		assertEquals(this.bar, listValueModel.get(0));
 		assertEquals(this.bar, synchList.get(0));
 		this.bar.removeStuff("bar");
 		this.bar.addStuff("zzz");
 		this.bar.addStuff("bar");
-		assertEquals(this.bar, listValueModel.getItem(5));
+		assertEquals(this.bar, listValueModel.get(5));
 		assertEquals(this.bar, synchList.get(5));
 		this.bar.removeStuff("zzz");
 	}
 
 	private void verifyHasNoListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private void verifyHasListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private CollectionValueModel buildCollectionHolder() {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemPropertyListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemPropertyListValueModelAdapterTests.java
index d9f2218da0..808ae1c950 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemPropertyListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemPropertyListValueModelAdapterTests.java
@@ -101,15 +101,15 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.addItem(6, this.tom);
-		listHolder.addItem(7, this.dick);
-		listHolder.addItem(8, this.harry);
+		listHolder.add(6, this.tom);
+		listHolder.add(7, this.dick);
+		listHolder.add(8, this.harry);
 		assertEquals(9, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(0);
-		listHolder.removeItem(4);
+		listHolder.remove(8);
+		listHolder.remove(0);
+		listHolder.remove(4);
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 
@@ -122,7 +122,7 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 	private void compare(ListValueModel listValueModel, List list) {
 		assertEquals(listValueModel.size(), list.size());
 		for (int i = 0; i < listValueModel.size(); i++) {
-			assertEquals(listValueModel.getItem(i), list.get(i));
+			assertEquals(listValueModel.get(i), list.get(i));
 		}
 	}
 
@@ -182,16 +182,16 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compareSort(listValueModel, synchList, comparator);
 
-		listHolder.addItem(0, this.tom);
-		listHolder.addItem(0, this.dick);
-		listHolder.addItem(0, this.harry);
+		listHolder.add(0, this.tom);
+		listHolder.add(0, this.dick);
+		listHolder.add(0, this.harry);
 		assertEquals(9, synchList.size());
 		this.compareSort(listValueModel, synchList, comparator);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(4);
-		listHolder.removeItem(0);
-		listHolder.removeItem(5);
+		listHolder.remove(8);
+		listHolder.remove(4);
+		listHolder.remove(0);
+		listHolder.remove(5);
 		assertEquals(5, synchList.size());
 		this.compareSort(listValueModel, synchList, comparator);
 
@@ -203,7 +203,7 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 	private void compareSort(ListValueModel listValueModel, List list, Comparator comparator) {
 		SortedSet ss = new TreeSet(comparator);
 		for (int i = 0; i < listValueModel.size(); i++) {
-			ss.add(listValueModel.getItem(i));
+			ss.add(listValueModel.get(i));
 		}
 		assertEquals(ss.size(), list.size());
 		for (Iterator stream1 = ss.iterator(), stream2 = list.iterator(); stream1.hasNext(); ) {
@@ -213,14 +213,14 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 
 	public void testHasListeners() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
 		assertFalse(this.foo.hasAnyPropertyChangeListeners(Displayable.ICON_PROPERTY));
 		assertFalse(this.jaz.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
 		assertFalse(this.jaz.hasAnyPropertyChangeListeners(Displayable.ICON_PROPERTY));
 
 		ListValueModel listValueModel = new ItemPropertyListValueModelAdapter(new SortedListValueModelAdapter(listHolder), Displayable.DISPLAY_STRING_PROPERTY, Displayable.ICON_PROPERTY);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
 		assertFalse(this.foo.hasAnyPropertyChangeListeners(Displayable.ICON_PROPERTY));
 		assertFalse(this.jaz.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
@@ -228,15 +228,15 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 		this.verifyHasNoListeners(listValueModel);
 
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
-		assertTrue(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.foo.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
 		assertTrue(this.foo.hasAnyPropertyChangeListeners(Displayable.ICON_PROPERTY));
 		assertTrue(this.jaz.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
 		assertTrue(this.jaz.hasAnyPropertyChangeListeners(Displayable.ICON_PROPERTY));
 		this.verifyHasListeners(listValueModel);
 
-		listValueModel.removeListChangeListener(ValueModel.VALUE, synchList);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		listValueModel.removeListChangeListener(ListValueModel.LIST_VALUES, synchList);
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
 		assertFalse(this.foo.hasAnyPropertyChangeListeners(Displayable.ICON_PROPERTY));
 		assertFalse(this.jaz.hasAnyPropertyChangeListeners(Displayable.DISPLAY_STRING_PROPERTY));
@@ -253,25 +253,25 @@ public class ItemPropertyListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 	}
 
-	public void testGetElementAt() throws Exception {
+	public void testGet() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
 		ListValueModel listValueModel = new SortedListValueModelAdapter(new ItemPropertyListValueModelAdapter(listHolder, Displayable.DISPLAY_STRING_PROPERTY, Displayable.ICON_PROPERTY));
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
 		this.verifyHasListeners(listValueModel);
-		assertEquals(this.bar, listValueModel.getItem(0));
+		assertEquals(this.bar, listValueModel.get(0));
 		assertEquals(this.bar, synchList.get(0));
 		this.bar.setName("zzz");
-		assertEquals(this.bar, listValueModel.getItem(5));
+		assertEquals(this.bar, listValueModel.get(5));
 		assertEquals(this.bar, synchList.get(5));
 		this.bar.setName("this.bar");
 	}
 
 	private void verifyHasNoListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private void verifyHasListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private SimpleCollectionValueModel buildCollectionHolder() {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemStateListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemStateListValueModelAdapterTests.java
index 1550ce7639..668e443abb 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemStateListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ItemStateListValueModelAdapterTests.java
@@ -95,15 +95,15 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.addItem(6, this.tom);
-		listHolder.addItem(7, this.dick);
-		listHolder.addItem(8, this.harry);
+		listHolder.add(6, this.tom);
+		listHolder.add(7, this.dick);
+		listHolder.add(8, this.harry);
 		assertEquals(9, synchList.size());
 		this.compare(listValueModel, synchList);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(0);
-		listHolder.removeItem(4);
+		listHolder.remove(8);
+		listHolder.remove(0);
+		listHolder.remove(4);
 		assertEquals(6, synchList.size());
 		this.compare(listValueModel, synchList);
 	}
@@ -111,7 +111,7 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 	private void compare(ListValueModel listValueModel, List list) {
 		assertEquals(listValueModel.size(), list.size());
 		for (int i = 0; i < listValueModel.size(); i++) {
-			assertEquals(listValueModel.getItem(i), list.get(i));
+			assertEquals(listValueModel.get(i), list.get(i));
 		}
 	}
 
@@ -167,16 +167,16 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compareSort(listValueModel, synchList, comparator);
 
-		listHolder.addItem(0, this.tom);
-		listHolder.addItem(0, this.dick);
-		listHolder.addItem(0, this.harry);
+		listHolder.add(0, this.tom);
+		listHolder.add(0, this.dick);
+		listHolder.add(0, this.harry);
 		assertEquals(9, synchList.size());
 		this.compareSort(listValueModel, synchList, comparator);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(4);
-		listHolder.removeItem(0);
-		listHolder.removeItem(5);
+		listHolder.remove(8);
+		listHolder.remove(4);
+		listHolder.remove(0);
+		listHolder.remove(5);
 		assertEquals(5, synchList.size());
 		this.compareSort(listValueModel, synchList, comparator);
 	}
@@ -184,7 +184,7 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 	private void compareSort(ListValueModel listValueModel, List list, Comparator comparator) {
 		SortedSet ss = new TreeSet(comparator);
 		for (int i = 0; i < listValueModel.size(); i++) {
-			ss.add(listValueModel.getItem(i));
+			ss.add(listValueModel.get(i));
 		}
 		assertEquals(ss.size(), list.size());
 		for (Iterator stream1 = ss.iterator(), stream2 = list.iterator(); stream1.hasNext(); ) {
@@ -194,14 +194,14 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 
 	public void testHasListeners() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyStateChangeListeners());
 		assertFalse(this.foo.hasAnyStateChangeListeners());
 		assertFalse(this.jaz.hasAnyStateChangeListeners());
 		assertFalse(this.jaz.hasAnyStateChangeListeners());
 
 		ListValueModel listValueModel = new ItemStateListValueModelAdapter(new SortedListValueModelAdapter(listHolder));
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyStateChangeListeners());
 		assertFalse(this.foo.hasAnyStateChangeListeners());
 		assertFalse(this.jaz.hasAnyStateChangeListeners());
@@ -209,15 +209,15 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 		this.verifyHasNoListeners(listValueModel);
 
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
-		assertTrue(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.foo.hasAnyStateChangeListeners());
 		assertTrue(this.foo.hasAnyStateChangeListeners());
 		assertTrue(this.jaz.hasAnyStateChangeListeners());
 		assertTrue(this.jaz.hasAnyStateChangeListeners());
 		this.verifyHasListeners(listValueModel);
 
-		listValueModel.removeListChangeListener(ValueModel.VALUE, synchList);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		listValueModel.removeListChangeListener(ListValueModel.LIST_VALUES, synchList);
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(this.foo.hasAnyStateChangeListeners());
 		assertFalse(this.foo.hasAnyStateChangeListeners());
 		assertFalse(this.jaz.hasAnyStateChangeListeners());
@@ -234,25 +234,25 @@ public class ItemStateListValueModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 	}
 
-	public void testGetElementAt() throws Exception {
+	public void testGet() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
 		ListValueModel listValueModel = new SortedListValueModelAdapter(new ItemStateListValueModelAdapter(listHolder));
 		SynchronizedList synchList = new SynchronizedList(listValueModel);
 		this.verifyHasListeners(listValueModel);
-		assertEquals(this.bar, listValueModel.getItem(0));
+		assertEquals(this.bar, listValueModel.get(0));
 		assertEquals(this.bar, synchList.get(0));
 		this.bar.setName("zzz");
-		assertEquals(this.bar, listValueModel.getItem(5));
+		assertEquals(this.bar, listValueModel.get(5));
 		assertEquals(this.bar, synchList.get(5));
 		this.bar.setName("this.bar");
 	}
 
 	private void verifyHasNoListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasNoListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private void verifyHasListeners(ListValueModel listValueModel) throws Exception {
-		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) listValueModel).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private CollectionValueModel buildCollectionHolder() {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListAspectAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListAspectAdapterTests.java
index 53a5615ed8..6e48f091d5 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListAspectAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListAspectAdapterTests.java
@@ -20,6 +20,7 @@ import org.eclipse.jpt.utility.internal.model.AbstractModel;
 import org.eclipse.jpt.utility.internal.model.event.ListChangeEvent;
 import org.eclipse.jpt.utility.internal.model.listener.ListChangeListener;
 import org.eclipse.jpt.utility.internal.model.value.ListAspectAdapter;
+import org.eclipse.jpt.utility.internal.model.value.ListValueModel;
 import org.eclipse.jpt.utility.internal.model.value.PropertyValueModel;
 import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
 import org.eclipse.jpt.utility.internal.model.value.ValueModel;
@@ -49,7 +50,7 @@ public class ListAspectAdapterTests extends TestCase {
 		this.subjectHolder1 = new SimplePropertyValueModel(this.subject1);
 		this.aa1 = this.buildAspectAdapter(this.subjectHolder1);
 		this.listener1 = this.buildValueChangeListener1();
-		this.aa1.addListChangeListener(ValueModel.VALUE, this.listener1);
+		this.aa1.addListChangeListener(ListValueModel.LIST_VALUES, this.listener1);
 		this.event1 = null;
 
 		this.subject2 = new TestSubject();
@@ -101,7 +102,7 @@ public class ListAspectAdapterTests extends TestCase {
 					throw new IllegalStateException("invalid aspect name: " + this.listName);
 				}
 			}
-			public void addItem(int index, Object item) {
+			public void add(int index, Object item) {
 				if (this.listName == TestSubject.NAMES_LIST) {
 					((TestSubject) this.subject).addName(index, (String) item);
 				} else if (this.listName == TestSubject.DESCRIPTIONS_LIST) {
@@ -110,7 +111,7 @@ public class ListAspectAdapterTests extends TestCase {
 					throw new IllegalStateException("invalid aspect name: " + this.listName);
 				}
 			}
-			public Object removeItem(int index) {
+			public Object remove(int index) {
 				if (this.listName == TestSubject.NAMES_LIST) {
 					return ((TestSubject) this.subject).removeName(index);
 				} else if (this.listName == TestSubject.DESCRIPTIONS_LIST) {
@@ -119,7 +120,7 @@ public class ListAspectAdapterTests extends TestCase {
 					throw new IllegalStateException("invalid aspect name: " + this.listName);
 				}
 			}
-			public Object replaceItem(int index, Object item) {
+			public Object replace(int index, Object item) {
 				if (this.listName == TestSubject.NAMES_LIST) {
 					return ((TestSubject) this.subject).setName(index, (String) item);
 				} else if (this.listName == TestSubject.DESCRIPTIONS_LIST) {
@@ -165,63 +166,63 @@ public class ListAspectAdapterTests extends TestCase {
 	}
 
 	public void testSubjectHolder() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		this.subjectHolder1.setValue(this.subject2);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
-		assertEquals(this.subject2Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(this.subject2Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		
 		this.event1 = null;
 		this.subjectHolder1.setValue(null);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
-		assertFalse(((Iterator) this.aa1.value()).hasNext());
+		assertFalse(((Iterator) this.aa1.values()).hasNext());
 		
 		this.event1 = null;
 		this.subjectHolder1.setValue(this.subject1);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testAddItem() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+	public void testAdd() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		this.subject1.addName("jam");
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(this.subject1Names().size(), this.event1.index());
 		assertEquals("jam", this.event1.items().next());
 		List namesPlus = this.subject1Names();
 		namesPlus.add("jam");
-		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.values()));
 
 		this.event1 = null;
-		this.aa1.addItem(2, "jaz");
+		this.aa1.add(2, "jaz");
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(2, this.event1.index());
 		assertEquals("jaz", this.event1.items().next());
 		namesPlus.add(2, "jaz");
-		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testDefaultAddItems() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+	public void testDefaultAdd() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		List items = new ArrayList();
@@ -231,44 +232,44 @@ public class ListAspectAdapterTests extends TestCase {
 		items.add("jam");
 
 		this.event1 = null;
-		this.aa1.addItems(2, items);
+		this.aa1.addAll(2, items);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(5, this.event1.index());		// only the last "add" event will still be there
 		assertEquals("jam", this.event1.items().next());
 		List namesPlus = this.subject1Names();
 		namesPlus.addAll(2, items);
-		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testRemoveItem() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+	public void testRemove() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		String removedName = this.subject1.removeName(0);	// should be "foo"
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(0, this.event1.index());
 		assertEquals(removedName, this.event1.items().next());
 		List namesMinus = this.subject1Names();
 		namesMinus.remove(0);
-		assertEquals(namesMinus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesMinus, CollectionTools.list((ListIterator) this.aa1.values()));
 
 		this.event1 = null;
-		Object removedItem = this.aa1.removeItem(0);	
+		Object removedItem = this.aa1.remove(0);	
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(0, this.event1.index());
 		assertEquals(removedItem, this.event1.items().next());
 		namesMinus.remove(0);
-		assertEquals(namesMinus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesMinus, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testDefaultRemoveItems() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+	public void testDefaultLength() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		List items = new ArrayList();
@@ -276,49 +277,49 @@ public class ListAspectAdapterTests extends TestCase {
 		items.add("baz");
 
 		this.event1 = null;
-		this.aa1.removeItems(1, 2);
+		this.aa1.remove(1, 2);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(1, this.event1.index());		// only the last "remove" event will still be there
 		assertEquals("baz", this.event1.items().next());
 		List namesPlus = this.subject1Names();
 		namesPlus.remove(1);
 		namesPlus.remove(1);
-		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testReplaceItem() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+	public void testReplace() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		String replacedName = this.subject1.setName(0, "jelly");	// should be "foo"
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(0, this.event1.index());
 		assertEquals("jelly", this.event1.items().next());
 		assertEquals(replacedName, this.event1.replacedItems().next());
 		List namesChanged = this.subject1Names();
 		namesChanged.set(0, "jelly");
-		assertEquals(namesChanged, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesChanged, CollectionTools.list((ListIterator) this.aa1.values()));
 
 		this.event1 = null;
 		replacedName = this.subject1.setName(1, "roll");	// should be "bar"
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(1, this.event1.index());
 		assertEquals("roll", this.event1.items().next());
 		assertEquals(replacedName, this.event1.replacedItems().next());
 		namesChanged = this.subject1Names();
 		namesChanged.set(0, "jelly");
 		namesChanged.set(1, "roll");
-		assertEquals(namesChanged, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesChanged, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testDefaultReplaceItems() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+	public void testDefaultReplaceAll() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		List items = new ArrayList();
@@ -326,64 +327,64 @@ public class ListAspectAdapterTests extends TestCase {
 		items.add("jaz");
 
 		this.event1 = null;
-		this.aa1.replaceItems(1, items);
+		this.aa1.replaceAll(1, items);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(2, this.event1.index());		// only the last "replace" event will still be there
 		assertEquals("baz", this.event1.replacedItems().next());
 		assertEquals("jaz", this.event1.items().next());
 		List namesPlus = this.subject1Names();
 		namesPlus.set(1, items.get(0));
 		namesPlus.set(2, items.get(1));
-		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesPlus, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
 	public void testListChange() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 		assertNull(this.event1);
 
 		this.subject1.addTwoNames("jam", "jaz");
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
 		List namesPlus2 = this.subject1Names();
 		namesPlus2.add(0, "jaz");
 		namesPlus2.add(0, "jam");
-		assertEquals(namesPlus2, CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(namesPlus2, CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testValue() {
+	public void testValues() {
 		assertEquals(this.subject1Names(), CollectionTools.list(this.subject1.names()));
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.aa1.values()));
 	}
 
-	public void testGetItem() {
+	public void testGet() {
 		assertEquals(this.subject1Names().get(0), this.subject1.getName(0));
-		assertEquals(this.subject1Names().get(0), this.aa1.getItem(0));
+		assertEquals(this.subject1Names().get(0), this.aa1.get(0));
 	}
 
 	public void testSize() {
 		assertEquals(this.subject1Names().size(), CollectionTools.size(this.subject1.names()));
-		assertEquals(this.subject1Names().size(), CollectionTools.size((ListIterator) this.aa1.value()));
+		assertEquals(this.subject1Names().size(), CollectionTools.size((ListIterator) this.aa1.values()));
 	}
 
 	public void testHasListeners() {
-		assertTrue(this.aa1.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(this.aa1.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.subject1.hasAnyListChangeListeners(TestSubject.NAMES_LIST));
-		this.aa1.removeListChangeListener(ValueModel.VALUE, this.listener1);
+		this.aa1.removeListChangeListener(ListValueModel.LIST_VALUES, this.listener1);
 		assertFalse(this.subject1.hasAnyListChangeListeners(TestSubject.NAMES_LIST));
-		assertFalse(this.aa1.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(this.aa1.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		ListChangeListener listener2 = this.buildValueChangeListener1();
 		this.aa1.addListChangeListener(listener2);
-		assertTrue(this.aa1.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(this.aa1.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.subject1.hasAnyListChangeListeners(TestSubject.NAMES_LIST));
 		this.aa1.removeListChangeListener(listener2);
 		assertFalse(this.subject1.hasAnyListChangeListeners(TestSubject.NAMES_LIST));
-		assertFalse(this.aa1.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(this.aa1.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 // ********** inner class **********
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCollectionValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCollectionValueModelAdapterTests.java
index 2fd8792cc7..3885b57eed 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCollectionValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCollectionValueModelAdapterTests.java
@@ -55,28 +55,28 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
+	public void testValues() {
 		this.adapter.addCollectionChangeListener(CollectionValueModel.VALUES, new TestListener() {
 			public void itemsAdded(CollectionChangeEvent e) {
 				// override failure
 			}
 		});
-		this.wrappedListHolder.addItem(0, "foo");
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
+		this.wrappedListHolder.add(0, "foo");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
 		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		assertEquals(this.wrappedCollection(), adapterCollection);
 	}
 
-	public void testStaleValue() {
+	public void testStaleValues() {
 		CollectionChangeListener listener = new TestListener() {
 			public void itemsAdded(CollectionChangeEvent e) {/* OK */}
 		};
 		this.adapter.addCollectionChangeListener(CollectionValueModel.VALUES, listener);
-		this.wrappedListHolder.addItem(0, "foo");
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
+		this.wrappedListHolder.add(0, "foo");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
 		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		assertEquals(this.wrappedCollection(), adapterCollection);
@@ -92,16 +92,16 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 		assertEquals(this.wrappedCollection(), adapterCollection);
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		Bag synchCollection = new SynchronizedBag(this.adapter);
 		List synchList = new SynchronizedList(this.wrappedListHolder);
-		this.wrappedListHolder.addItem(0, "foo");
+		this.wrappedListHolder.add(0, "foo");
 		assertTrue(this.wrappedList.contains("foo"));
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
-		this.wrappedListHolder.addItem(3, "joo");
-		this.wrappedListHolder.addItem(4, "jar");
-		this.wrappedListHolder.addItem(5, "jaz");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
+		this.wrappedListHolder.add(3, "joo");
+		this.wrappedListHolder.add(4, "jar");
+		this.wrappedListHolder.add(5, "jaz");
 		assertEquals(6, this.wrappedList.size());
 
 		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
@@ -110,18 +110,18 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 		assertEquals(this.wrappedCollection(), synchCollection);
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		Bag synchCollection = new SynchronizedBag(this.adapter);
 		List synchList = new SynchronizedList(this.wrappedListHolder);
-		this.wrappedListHolder.addItem(0, "foo");
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
-		this.wrappedListHolder.addItem(3, "joo");
-		this.wrappedListHolder.addItem(4, "jar");
-		this.wrappedListHolder.addItem(5, "jaz");
-		assertEquals("jaz", this.wrappedListHolder.removeItem(5));
+		this.wrappedListHolder.add(0, "foo");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
+		this.wrappedListHolder.add(3, "joo");
+		this.wrappedListHolder.add(4, "jar");
+		this.wrappedListHolder.add(5, "jaz");
+		assertEquals("jaz", this.wrappedListHolder.remove(5));
 		assertFalse(this.wrappedList.contains("jaz"));
-		assertEquals("foo", this.wrappedListHolder.removeItem(0));
+		assertEquals("foo", this.wrappedListHolder.remove(0));
 		assertFalse(this.wrappedList.contains("foo"));
 		assertEquals(4, this.wrappedList.size());
 
@@ -140,15 +140,15 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 				// override failure
 			}
 		});
-		this.wrappedListHolder.addItem(0, "foo");
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
-		this.wrappedListHolder.addItem(3, "joo");
-		this.wrappedListHolder.addItem(4, "jar");
-		this.wrappedListHolder.addItem(5, "jaz");
-		this.wrappedListHolder.removeItem(5);
+		this.wrappedListHolder.add(0, "foo");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
+		this.wrappedListHolder.add(3, "joo");
+		this.wrappedListHolder.add(4, "jar");
+		this.wrappedListHolder.add(5, "jaz");
+		this.wrappedListHolder.remove(5);
 		assertFalse(this.wrappedList.contains("jaz"));
-		this.wrappedListHolder.removeItem(0);
+		this.wrappedListHolder.remove(0);
 		assertFalse(this.wrappedList.contains("foo"));
 		assertEquals(4, this.wrappedList.size());
 
@@ -156,7 +156,7 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 		assertEquals(this.wrappedCollection(), adapterCollection);
 	}
 
-	public void testReplaceItem() {
+	public void testReplace() {
 		this.adapter.addCollectionChangeListener(CollectionValueModel.VALUES, new TestListener() {
 			public void itemsAdded(CollectionChangeEvent e) {
 				// override failure
@@ -165,9 +165,9 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 				// override failure
 			}
 		});
-		this.wrappedListHolder.addItem(0, "foo");
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
+		this.wrappedListHolder.add(0, "foo");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
 		Collection adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		this.adapter.addCollectionChangeListener(CollectionValueModel.VALUES, new TestListener() {
@@ -181,7 +181,7 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 				assertEquals(3, ListCollectionValueModelAdapterTests.this.adapter.size());
 			}
 		});
-		this.wrappedListHolder.replaceItem(0, "joo");
+		this.wrappedListHolder.replace(0, "joo");
 		adapterCollection = CollectionTools.collection((Iterator) this.adapter.values());
 		assertEquals(3, adapterCollection.size());
 		assertEquals(this.wrappedCollection(), adapterCollection);
@@ -204,9 +204,9 @@ public class ListCollectionValueModelAdapterTests extends TestCase {
 			public void itemsAdded(CollectionChangeEvent e) {/* OK */}
 			public void itemsRemoved(CollectionChangeEvent e) {/* OK */}
 		});
-		this.wrappedListHolder.addItem(0, "foo");
-		this.wrappedListHolder.addItem(1, "bar");
-		this.wrappedListHolder.addItem(2, "baz");
+		this.wrappedListHolder.add(0, "foo");
+		this.wrappedListHolder.add(1, "bar");
+		this.wrappedListHolder.add(2, "baz");
 		JList jList = new JList(new ListModelAdapter(this.adapter));
 		((SimpleListValueModel) this.wrappedListHolder).setValue(new ArrayList());
 		assertEquals(0, jList.getModel().getSize());
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCuratorTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCuratorTests.java
index 49088a9f2a..d29e6a1786 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCuratorTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ListCuratorTests.java
@@ -20,6 +20,7 @@ import org.eclipse.jpt.utility.internal.model.AbstractModel;
 import org.eclipse.jpt.utility.internal.model.event.ListChangeEvent;
 import org.eclipse.jpt.utility.internal.model.listener.ListChangeListener;
 import org.eclipse.jpt.utility.internal.model.value.ListCurator;
+import org.eclipse.jpt.utility.internal.model.value.ListValueModel;
 import org.eclipse.jpt.utility.internal.model.value.PropertyValueModel;
 import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
 import org.eclipse.jpt.utility.internal.model.value.ValueModel;
@@ -50,7 +51,7 @@ public final class ListCuratorTests
 		this.subjectHolder1 = new SimplePropertyValueModel(this.subject1);
 		this.curator = this.buildListCurator(this.subjectHolder1);
 		this.listener1 = this.buildListChangeListener1();
-		this.curator.addListChangeListener(ValueModel.VALUE, this.listener1);
+		this.curator.addListChangeListener(ListValueModel.LIST_VALUES, this.listener1);
 		this.event1 = null;
 		
 		this.subject2 = new TestSubject(this.subject2Names());
@@ -116,99 +117,99 @@ public final class ListCuratorTests
 	}
 
 	public void testSubjectHolder() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.values()));
 		assertNull(this.event1);
 
 		this.subjectHolder1.setValue(this.subject2);
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
-		assertEquals(this.subject2Names(), CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(this.subject2Names(), CollectionTools.list((ListIterator) this.curator.values()));
 		
 		this.event1 = null;
 		this.subjectHolder1.setValue(null);
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
-		assertFalse(((Iterator) this.curator.value()).hasNext());
+		assertFalse(((Iterator) this.curator.values()).hasNext());
 		
 		this.event1 = null;
 		this.subjectHolder1.setValue(this.subject1);
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(-1, this.event1.index());
 		assertFalse(this.event1.items().hasNext());
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.values()));
 	}
 
-	public void testAddItem() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.value()));
+	public void testAdd() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.values()));
 		assertNull(this.event1);
 
 		this.subject1.addString("echo");
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(this.subject1Names().size(), this.event1.index());
 		assertEquals("echo", this.event1.items().next());
 		List stringsPlus = this.subject1Names();
 		stringsPlus.add("echo");
-		assertEquals(stringsPlus, CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(stringsPlus, CollectionTools.list((ListIterator) this.curator.values()));
 
 		this.event1 = null;
 		this.subject1.addString(0, "zulu");
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(0, this.event1.index());
 		assertEquals("zulu", this.event1.items().next());
 		stringsPlus.add(0, "zulu");
-		assertEquals(stringsPlus, CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(stringsPlus, CollectionTools.list((ListIterator) this.curator.values()));
 	}
 	
-	public void testRemoveItem() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.value()));
+	public void testRemove() {
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.values()));
 		assertNull(this.event1);
 
 		String removedString = this.subject1.removeString(0);	// should be "alpha"
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(0, this.event1.index());
 		assertEquals(removedString, this.event1.items().next());
 		List stringsMinus = this.subject1Names();
 		stringsMinus.remove(0);
-		assertEquals(stringsMinus, CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(stringsMinus, CollectionTools.list((ListIterator) this.curator.values()));
 		
 		removedString = this.subject1.removeString(2);	// should be "delta"
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(2, this.event1.index());
 		assertEquals(removedString, this.event1.items().next());
 		stringsMinus.remove(2);
-		assertEquals(stringsMinus, CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(stringsMinus, CollectionTools.list((ListIterator) this.curator.values()));
 	}
 	
 	public void testCompleteListChange() {
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.values()));
 		assertNull(this.event1);
 		
 		this.subject1.setStrings(this.subject2Names());
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		List newStrings = this.subject2Names();
-		assertEquals(newStrings, CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(newStrings, CollectionTools.list((ListIterator) this.curator.values()));
 	}
 	
 	public void testPartialListChange() {
-		List startingList = CollectionTools.list((ListIterator) this.curator.value());
+		List startingList = CollectionTools.list((ListIterator) this.curator.values());
 		assertEquals(this.subject1Names(), startingList);
 		assertNull(this.event1);
 		
@@ -217,45 +218,45 @@ public final class ListCuratorTests
 		List newStrings = CollectionTools.list(new String[] {new String("bravo"), new String("alpha"), "echo", "delta", "foxtrot"});
 		this.subject1.setStrings(newStrings);
 		
-		List finalList = CollectionTools.list((ListIterator) this.curator.value());
+		List finalList = CollectionTools.list((ListIterator) this.curator.values());
 		assertNotNull(this.event1);
 		assertEquals(this.curator, this.event1.getSource());
-		assertEquals(ValueModel.VALUE, this.event1.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event1.listName());
 		assertEquals(newStrings, finalList);
 		assertTrue(identicalString == finalList.get(0));
 		assertTrue(nonidenticalString != finalList.get(1));
 	}
 	
-	public void testValue() {
+	public void testValues() {
 		assertEquals(this.subject1Names(), CollectionTools.list(this.subject1.strings()));
-		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.value()));
+		assertEquals(this.subject1Names(), CollectionTools.list((ListIterator) this.curator.values()));
 	}
 	
-	public void testGetItem() {
+	public void testGet() {
 		assertEquals(this.subject1Names().get(0), this.subject1.getString(0));
-		assertEquals(this.subject1Names().get(0), this.curator.getItem(0));
+		assertEquals(this.subject1Names().get(0), this.curator.get(0));
 	}
 	
 	public void testSize() {
 		assertEquals(this.subject1Names().size(), CollectionTools.size(this.subject1.strings()));
-		assertEquals(this.subject1Names().size(), CollectionTools.size((ListIterator) this.curator.value()));
+		assertEquals(this.subject1Names().size(), CollectionTools.size((ListIterator) this.curator.values()));
 		assertEquals(this.subject1Names().size(), this.curator.size());
 	}
 	
 	public void testHasListeners() {
-		assertTrue(this.curator.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(this.curator.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.subject1.hasAnyStateChangeListeners());
-		this.curator.removeListChangeListener(ValueModel.VALUE, this.listener1);
+		this.curator.removeListChangeListener(ListValueModel.LIST_VALUES, this.listener1);
 		assertFalse(this.subject1.hasAnyStateChangeListeners());
-		assertFalse(this.curator.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(this.curator.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		ListChangeListener listener2 = this.buildListChangeListener1();
 		this.curator.addListChangeListener(listener2);
-		assertTrue(this.curator.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(this.curator.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(this.subject1.hasAnyStateChangeListeners());
 		this.curator.removeListChangeListener(listener2);
 		assertFalse(this.subject1.hasAnyStateChangeListeners());
-		assertFalse(this.curator.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(this.curator.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 	
 	
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullCollectionValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullCollectionValueModelTests.java
index 6b026eed79..d01c5be2e4 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullCollectionValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullCollectionValueModelTests.java
@@ -38,7 +38,7 @@ public class NullCollectionValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		boolean exCaught = false;
 		try {
 			this.collectionHolder.add("foo");
@@ -48,7 +48,7 @@ public class NullCollectionValueModelTests extends TestCase {
 		assertTrue(exCaught);
 	}
 
-	public void testAddItems() {
+	public void testAddAll() {
 		boolean exCaught = false;
 		Collection<String> items = new ArrayList<String>();
 		items.add("foo");
@@ -62,7 +62,7 @@ public class NullCollectionValueModelTests extends TestCase {
 		assertTrue(exCaught);
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		boolean exCaught = false;
 		try {
 			this.collectionHolder.remove("foo");
@@ -72,7 +72,7 @@ public class NullCollectionValueModelTests extends TestCase {
 		assertTrue(exCaught);
 	}
 
-	public void testRemoveItems() {
+	public void testRemoveAll() {
 		boolean exCaught = false;
 		Collection<String> items = new ArrayList<String>();
 		items.add("foo");
@@ -90,7 +90,7 @@ public class NullCollectionValueModelTests extends TestCase {
 		assertEquals(0, this.collectionHolder.size());
 	}
 
-	public void testValue() {
+	public void testValues() {
 		assertFalse(((Iterator) this.collectionHolder.values()).hasNext());
 	}
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullListValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullListValueModelTests.java
index 26c76b76f8..ef16aa5d84 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullListValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/NullListValueModelTests.java
@@ -38,78 +38,78 @@ public class NullListValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		boolean exCaught = false;
 		try {
-			this.listHolder.addItem(0, "foo");
+			this.listHolder.add(0, "foo");
 		} catch (UnsupportedOperationException ex) {
 			exCaught = true;
 		}
 		assertTrue(exCaught);
 	}
 
-	public void testAddItems() {
+	public void testAddAll() {
 		boolean exCaught = false;
 		List<String> items = new ArrayList<String>();
 		items.add("foo");
 		items.add("bar");
 		items.add("baz");
 		try {
-			this.listHolder.addItems(0, items);
+			this.listHolder.addAll(0, items);
 		} catch (UnsupportedOperationException ex) {
 			exCaught = true;
 		}
 		assertTrue(exCaught);
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		boolean exCaught = false;
 		try {
-			this.listHolder.removeItem(0);
+			this.listHolder.remove(0);
 		} catch (UnsupportedOperationException ex) {
 			exCaught = true;
 		}
 		assertTrue(exCaught);
 	}
 
-	public void testRemoveItems() {
+	public void testRemoveLength() {
 		boolean exCaught = false;
 		try {
-			this.listHolder.removeItems(0, 3);
+			this.listHolder.remove(0, 3);
 		} catch (UnsupportedOperationException ex) {
 			exCaught = true;
 		}
 		assertTrue(exCaught);
 	}
 
-	public void testReplaceItem() {
+	public void testReplace() {
 		boolean exCaught = false;
 		try {
-			this.listHolder.replaceItem(0, "foo");
+			this.listHolder.replace(0, "foo");
 		} catch (UnsupportedOperationException ex) {
 			exCaught = true;
 		}
 		assertTrue(exCaught);
 	}
 
-	public void testReplaceItems() {
+	public void testReplaceAll() {
 		boolean exCaught = false;
 		List<String> items = new ArrayList<String>();
 		items.add("foo");
 		items.add("bar");
 		items.add("baz");
 		try {
-			this.listHolder.replaceItems(0, items);
+			this.listHolder.replaceAll(0, items);
 		} catch (UnsupportedOperationException ex) {
 			exCaught = true;
 		}
 		assertTrue(exCaught);
 	}
 
-	public void testGetItem() {
+	public void testGet() {
 		boolean exCaught = false;
 		try {
-			this.listHolder.getItem(0);
+			this.listHolder.get(0);
 		} catch (IndexOutOfBoundsException ex) {
 			exCaught = true;
 		}
@@ -120,8 +120,8 @@ public class NullListValueModelTests extends TestCase {
 		assertEquals(0, this.listHolder.size());
 	}
 
-	public void testValue() {
-		assertFalse(((ListIterator) this.listHolder.value()).hasNext());
+	public void testValues() {
+		assertFalse(((ListIterator) this.listHolder.values()).hasNext());
 	}
 
 }
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/PropertyCollectionValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/PropertyCollectionValueModelAdapterTests.java
index b91ed941db..c635335f65 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/PropertyCollectionValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/PropertyCollectionValueModelAdapterTests.java
@@ -51,7 +51,7 @@ public class PropertyCollectionValueModelAdapterTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
+	public void testValues() {
 		this.adapter.addCollectionChangeListener(CollectionValueModel.VALUES, new TestListener() {
 			public void itemsAdded(CollectionChangeEvent e) {/* OK */}
 		});
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyCollectionValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyCollectionValueModelTests.java
index 0cb8e11f2a..813198f1c1 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyCollectionValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyCollectionValueModelTests.java
@@ -67,7 +67,7 @@ public class ReadOnlyCollectionValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
+	public void testValues() {
 		assertEquals(buildCollection(), CollectionTools.bag((Iterator) this.collectionHolder.values()));
 	}
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyListValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyListValueModelTests.java
index f92c6f25aa..10b5b22d50 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyListValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/ReadOnlyListValueModelTests.java
@@ -38,7 +38,7 @@ public class ReadOnlyListValueModelTests extends TestCase {
 
 	private ListValueModel buildListHolder() {
 		return new AbstractReadOnlyListValueModel() {
-			public Object value() {
+			public ListIterator values() {
 				return ReadOnlyListValueModelTests.list();
 			}
 		};
@@ -68,15 +68,15 @@ public class ReadOnlyListValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testGetItem() {
+	public void testGet() {
 		List<String> expected = buildList();
 		for (int i = 0; i < this.listHolder.size(); i++) {
-			assertEquals(expected.get(i), this.listHolder.getItem(i));
+			assertEquals(expected.get(i), this.listHolder.get(i));
 		}
 	}
 
-	public void testValue() {
-		assertEquals(buildList(), CollectionTools.list((Iterator) this.listHolder.value()));
+	public void testValues() {
+		assertEquals(buildList(), CollectionTools.list((Iterator) this.listHolder.values()));
 	}
 
 	public void testSize() {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleCollectionValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleCollectionValueModelTests.java
index 417fabcc5f..599fc6a537 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleCollectionValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleCollectionValueModelTests.java
@@ -88,7 +88,7 @@ public class SimpleCollectionValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
+	public void testValues() {
 		assertEquals(this.buildBag(), CollectionTools.bag((Iterator) this.bagHolder.values()));
 		assertEquals(this.buildSet(), CollectionTools.set((Iterator) this.setHolder.values()));
 	}
@@ -134,7 +134,7 @@ public class SimpleCollectionValueModelTests extends TestCase {
 		return false;
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		assertFalse(this.bagHolderContains("joo"));
 		this.bagHolder.add("joo");
 		assertTrue(this.bagHolderContains("joo"));
@@ -152,7 +152,7 @@ public class SimpleCollectionValueModelTests extends TestCase {
 		assertTrue(this.setHolderContains(null));
 	}
 
-	public void testAddItems() {
+	public void testAddAll() {
 		assertFalse(this.bagHolderContainsAny(this.buildAddItems()));
 		this.bagHolder.addAll(this.buildAddItems());
 		assertTrue(this.bagHolderContainsAll(this.buildAddItems()));
@@ -162,7 +162,7 @@ public class SimpleCollectionValueModelTests extends TestCase {
 		assertTrue(this.setHolderContainsAll(this.buildAddItems()));
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		assertTrue(this.bagHolderContains("bar"));
 		this.bagHolder.remove("bar");
 		assertFalse(this.bagHolderContains("bar"));
@@ -182,7 +182,7 @@ public class SimpleCollectionValueModelTests extends TestCase {
 		assertFalse(this.setHolderContains(null));
 	}
 
-	public void testRemoveItems() {
+	public void testRemoveAll() {
 		assertTrue(this.bagHolderContainsAll(this.buildRemoveItems()));
 		this.bagHolder.removeAll(this.buildRemoveItems());
 		assertFalse(this.bagHolderContainsAny(this.buildRemoveItems()));
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleListValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleListValueModelTests.java
index c360caaeb4..b4ef523c18 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleListValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SimpleListValueModelTests.java
@@ -77,24 +77,24 @@ public class SimpleListValueModelTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
-		assertEquals(this.buildList(), CollectionTools.list((Iterator) this.listHolder.value()));
+	public void testValues() {
+		assertEquals(this.buildList(), CollectionTools.list((Iterator) this.listHolder.values()));
 	}
 
 	public void testSize() {
-		assertEquals(this.buildList().size(), CollectionTools.size((Iterator) this.listHolder.value()));
+		assertEquals(this.buildList().size(), CollectionTools.size((Iterator) this.listHolder.values()));
 	}
 
 	private boolean listContains(Object item) {
-		return CollectionTools.contains((Iterator) this.listHolder.value(), item);
+		return CollectionTools.contains((Iterator) this.listHolder.values(), item);
 	}
 
 	private boolean listContainsAll(Collection items) {
-		return CollectionTools.containsAll((Iterator) this.listHolder.value(), items);
+		return CollectionTools.containsAll((Iterator) this.listHolder.values(), items);
 	}
 
 	private boolean listContainsAny(Collection items) {
-		List list = CollectionTools.list((ListIterator) this.listHolder.value());
+		List list = CollectionTools.list((ListIterator) this.listHolder.values());
 		for (Iterator stream = items.iterator(); stream.hasNext(); ) {
 			if (list.contains(stream.next())) {
 				return true;
@@ -103,40 +103,40 @@ public class SimpleListValueModelTests extends TestCase {
 		return false;
 	}
 
-	public void testAddItem() {
+	public void testAdd() {
 		assertFalse(this.listContains("joo"));
-		this.listHolder.addItem(2, "joo");
+		this.listHolder.add(2, "joo");
 		assertTrue(this.listContains("joo"));
 
 		assertFalse(this.listContains(null));
-		this.listHolder.addItem(0, null);
+		this.listHolder.add(0, null);
 		assertTrue(this.listContains(null));
 	}
 
-	public void testAddItems() {
+	public void testAddAll() {
 		assertFalse(this.listContainsAny(this.buildAddList()));
-		this.listHolder.addItems(2, this.buildAddList());
+		this.listHolder.addAll(2, this.buildAddList());
 		assertTrue(this.listContainsAll(this.buildAddList()));
 	}
 
-	public void testRemoveItem() {
+	public void testRemove() {
 		assertTrue(this.listContains("bar"));
-		this.listHolder.removeItem(this.buildList().indexOf("bar"));
+		this.listHolder.remove(this.buildList().indexOf("bar"));
 		assertFalse(this.listContains("bar"));
 
-		this.listHolder.addItem(1, null);
+		this.listHolder.add(1, null);
 		assertTrue(this.listContains(null));
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		assertFalse(this.listContains(null));
 	}
 
-	public void testRemoveItems() {
+	public void testRemoveLength() {
 		assertTrue(this.listContainsAll(this.buildRemoveList()));
-		this.listHolder.removeItems(0, 2);
+		this.listHolder.remove(0, 2);
 		assertFalse(this.listContainsAny(this.buildRemoveList()));
 	}
 
-	public void testSetValue() {
+	public void testSetValues() {
 		List newList = new ArrayList();
 		newList.add("joo");
 		newList.add("jar");
@@ -148,9 +148,9 @@ public class SimpleListValueModelTests extends TestCase {
 		assertFalse(this.listContains("bar"));
 		assertTrue(this.listContains("jar"));
 
-		this.listHolder.addItem(1, null);
+		this.listHolder.add(1, null);
 		assertTrue(this.listContains(null));
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		assertFalse(this.listContains(null));
 
 		((SimpleListValueModel) this.listHolder).setValue(null);
@@ -163,29 +163,29 @@ public class SimpleListValueModelTests extends TestCase {
 	}
 
 	public void testListChange2() {
-		this.listHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+		this.listHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 		this.verifyListChange();
 	}
 
 	private void verifyListChange() {
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItem(1, "joo");
+		this.listHolder.add(1, "joo");
 		this.verifyEvent(ADD, 1, "joo");
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItem(1, null);
+		this.listHolder.add(1, null);
 		this.verifyEvent(ADD, 1, null);
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		this.verifyEvent(REMOVE, 1, null);
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		this.verifyEvent(REMOVE, 1, "joo");
 
 		this.event = null;
@@ -195,13 +195,13 @@ public class SimpleListValueModelTests extends TestCase {
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItems(0, this.buildList());
+		this.listHolder.addAll(0, this.buildList());
 		this.verifyEvent(ADD);
 		assertEquals(this.buildList(), CollectionTools.list(this.event.items()));
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.replaceItem(0, "joo");
+		this.listHolder.replace(0, "joo");
 		this.verifyEvent(REPLACE);
 		assertFalse(CollectionTools.contains(this.event.items(), "foo"));
 		assertTrue(CollectionTools.contains(this.event.items(), "joo"));
@@ -239,7 +239,7 @@ public class SimpleListValueModelTests extends TestCase {
 	private void verifyEvent(String e) {
 		assertEquals(e, this.eventType);
 		assertEquals(this.listHolder, this.event.getSource());
-		assertEquals(ValueModel.VALUE, this.event.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event.listName());
 	}
 
 	private void verifyEvent(String e, int index, Object item) {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java
index 919705308f..8cb9901bb9 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java
@@ -64,12 +64,12 @@ public class SortedListValueModelAdapterTests extends TestCase {
 		Collection sortedSet = new TreeSet(comparator);
 		sortedSet.addAll(expected);
 		List expectedList = new ArrayList(sortedSet);
-		List actualList = CollectionTools.list((ListIterator) actual.value());
+		List actualList = CollectionTools.list((ListIterator) actual.values());
 		assertEquals(expectedList, actualList);
 	}
 
-	public void testGetValue() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+	public void testAdd() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 			public void itemsReplaced(ListChangeEvent e) {/* OK */}
 		});
@@ -118,7 +118,7 @@ public class SortedListValueModelAdapterTests extends TestCase {
 	}
 
 	public void testListSynch() {
-		this.adapter.addListChangeListener(ValueModel.VALUE, new TestListChangeListener() {
+		this.adapter.addListChangeListener(ListValueModel.LIST_VALUES, new TestListChangeListener() {
 			public void itemsAdded(ListChangeEvent e) {/* OK */}
 			public void itemsRemoved(ListChangeEvent e) {/* OK */}
 			public void itemsReplaced(ListChangeEvent e) {/* OK */}
@@ -161,15 +161,15 @@ public class SortedListValueModelAdapterTests extends TestCase {
 	}
 
 	public void testHasListeners() {
-		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		SynchronizedList synchList = new SynchronizedList(this.adapter);
-		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
-		this.adapter.removeListChangeListener(ValueModel.VALUE, synchList);
-		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
+		this.adapter.removeListChangeListener(ListValueModel.LIST_VALUES, synchList);
+		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.adapter.addListChangeListener(synchList);
-		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.adapter.removeListChangeListener(synchList);
-		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.adapter).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private class TestListChangeListener implements ListChangeListener {
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SynchronizedList.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SynchronizedList.java
index 63d3d5f1c4..5893c7bb1b 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SynchronizedList.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/SynchronizedList.java
@@ -23,7 +23,6 @@ import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.model.event.ListChangeEvent;
 import org.eclipse.jpt.utility.internal.model.listener.ListChangeListener;
 import org.eclipse.jpt.utility.internal.model.value.ListValueModel;
-import org.eclipse.jpt.utility.internal.model.value.ValueModel;
 
 /**
  * Helper class that keeps an internal list in synch with the
@@ -33,8 +32,8 @@ public class SynchronizedList<E> implements List<E>, ListChangeListener, ListDat
 	private List<E> synchList = new ArrayList<E>();
 
 	public SynchronizedList(ListValueModel listValueModel) {
-		listValueModel.addListChangeListener(ValueModel.VALUE, this);
-		for (Iterator<E> stream = (ListIterator<E>) listValueModel.value(); stream.hasNext(); ) {
+		listValueModel.addListChangeListener(ListValueModel.LIST_VALUES, this);
+		for (Iterator<E> stream = (ListIterator<E>) listValueModel.values(); stream.hasNext(); ) {
 			this.add(stream.next());
 		}
 	}
@@ -176,7 +175,7 @@ public class SynchronizedList<E> implements List<E>, ListChangeListener, ListDat
 
 	public void listChanged(ListChangeEvent e) {
 		this.synchList.clear();
-		CollectionTools.addAll(this.synchList, (Iterator) ((ListValueModel) e.getSource()).value());
+		CollectionTools.addAll(this.synchList, (Iterator) ((ListValueModel) e.getSource()).values());
 	}
 
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/TransformationListValueModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/TransformationListValueModelAdapterTests.java
index ac5bef16ae..1558318748 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/TransformationListValueModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/TransformationListValueModelAdapterTests.java
@@ -116,35 +116,35 @@ public class TransformationListValueModelAdapterTests extends TestCase {
 		super.tearDown();
 	}
 
-	public void testValue() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
-		assertEquals(this.buildTransformedList(), CollectionTools.list((Iterator) this.transformedListHolder.value()));
+	public void testValues() {
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
+		assertEquals(this.buildTransformedList(), CollectionTools.list((Iterator) this.transformedListHolder.values()));
 	}
 
-	public void testStaleValue() {
+	public void testStaleValues() {
 		ListChangeListener listener = this.buildListener();
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, listener);
-		assertEquals(this.buildTransformedList(), CollectionTools.list((Iterator) this.transformedListHolder.value()));
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, listener);
+		assertEquals(this.buildTransformedList(), CollectionTools.list((Iterator) this.transformedListHolder.values()));
 
-		this.transformedListHolder.removeListChangeListener(ValueModel.VALUE, listener);
-		assertEquals(Collections.EMPTY_LIST, CollectionTools.list((Iterator) this.transformedListHolder.value()));
+		this.transformedListHolder.removeListChangeListener(ListValueModel.LIST_VALUES, listener);
+		assertEquals(Collections.EMPTY_LIST, CollectionTools.list((Iterator) this.transformedListHolder.values()));
 	}
 
 	public void testSize() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
-		assertEquals(this.buildTransformedList().size(), CollectionTools.size((Iterator) this.transformedListHolder.value()));
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
+		assertEquals(this.buildTransformedList().size(), CollectionTools.size((Iterator) this.transformedListHolder.values()));
 	}
 
 	private boolean transformedListContains(Object item) {
-		return CollectionTools.contains((Iterator) this.transformedListHolder.value(), item);
+		return CollectionTools.contains((Iterator) this.transformedListHolder.values(), item);
 	}
 
 	private boolean transformedListContainsAll(Collection items) {
-		return CollectionTools.containsAll((Iterator) this.transformedListHolder.value(), items);
+		return CollectionTools.containsAll((Iterator) this.transformedListHolder.values(), items);
 	}
 
 	private boolean transformedListContainsAny(Collection items) {
-		List transformedList = CollectionTools.list((ListIterator) this.transformedListHolder.value());
+		List transformedList = CollectionTools.list((ListIterator) this.transformedListHolder.values());
 		for (Iterator stream = items.iterator(); stream.hasNext(); ) {
 			if (transformedList.contains(stream.next())) {
 				return true;
@@ -153,44 +153,44 @@ public class TransformationListValueModelAdapterTests extends TestCase {
 		return false;
 	}
 
-	public void testAddItem() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAdd() {
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.transformedListContains("JOO"));
-		this.listHolder.addItem(2, "joo");
+		this.listHolder.add(2, "joo");
 		assertTrue(this.transformedListContains("JOO"));
 
 		assertFalse(this.transformedListContains(null));
-		this.listHolder.addItem(0, null);
+		this.listHolder.add(0, null);
 		assertTrue(this.transformedListContains(null));
 	}
 
-	public void testAddItems() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testAddAll() {
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertFalse(this.transformedListContainsAny(this.buildTransformedAddList()));
-		this.listHolder.addItems(2, this.buildAddList());
+		this.listHolder.addAll(2, this.buildAddList());
 		assertTrue(this.transformedListContainsAll(this.buildTransformedAddList()));
 	}
 
-	public void testRemoveItem() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemove() {
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.transformedListContains("BAR"));
-		this.listHolder.removeItem(this.buildList().indexOf("bar"));
+		this.listHolder.remove(this.buildList().indexOf("bar"));
 		assertFalse(this.transformedListContains("BAR"));
 
-		this.listHolder.addItem(1, null);
+		this.listHolder.add(1, null);
 		assertTrue(this.transformedListContains(null));
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		assertFalse(this.transformedListContains(null));
 	}
 
-	public void testRemoveItems() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+	public void testRemoveLength() {
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 
 		assertTrue(this.transformedListContainsAll(this.buildTransformedRemoveList()));
-		this.listHolder.removeItems(0, 2);
+		this.listHolder.remove(0, 2);
 		assertFalse(this.transformedListContainsAny(this.buildTransformedRemoveList()));
 	}
 
@@ -200,40 +200,40 @@ public class TransformationListValueModelAdapterTests extends TestCase {
 	}
 
 	public void testListChangeNamed() {
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, this.buildListener());
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, this.buildListener());
 		this.verifyListChange();
 	}
 
 	private void verifyListChange() {
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItem(1, "joo");
+		this.listHolder.add(1, "joo");
 		this.verifyEvent(ADD, 1, "JOO");
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItem(1, null);
+		this.listHolder.add(1, null);
 		this.verifyEvent(ADD, 1, null);
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		this.verifyEvent(REMOVE, 1, null);
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.removeItem(1);
+		this.listHolder.remove(1);
 		this.verifyEvent(REMOVE, 1, "JOO");
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.addItems(0, this.buildList());
+		this.listHolder.addAll(0, this.buildList());
 		this.verifyEvent(ADD);
 		assertEquals(this.buildTransformedList(), CollectionTools.list(this.event.items()));
 
 		this.event = null;
 		this.eventType = null;
-		this.listHolder.replaceItem(0, "joo");
+		this.listHolder.replace(0, "joo");
 		this.verifyEvent(REPLACE);
 		assertFalse(CollectionTools.contains(this.event.items(), "FOO"));
 		assertTrue(CollectionTools.contains(this.event.items(), "JOO"));
@@ -271,7 +271,7 @@ public class TransformationListValueModelAdapterTests extends TestCase {
 	private void verifyEvent(String type) {
 		assertEquals(type, this.eventType);
 		assertEquals(this.transformedListHolder, this.event.getSource());
-		assertEquals(ValueModel.VALUE, this.event.listName());
+		assertEquals(ListValueModel.LIST_VALUES, this.event.listName());
 	}
 
 	private void verifyEvent(String type, int index, Object item) {
@@ -287,21 +287,21 @@ public class TransformationListValueModelAdapterTests extends TestCase {
 		 * likewise, removing listeners from the transformed list will
 		 * cause listeners to be removed from the wrapped list
 		 */
-		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		ListChangeListener listener = this.buildListener();
 
-		this.transformedListHolder.addListChangeListener(ValueModel.VALUE, listener);
-		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		this.transformedListHolder.addListChangeListener(ListValueModel.LIST_VALUES, listener);
+		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
-		this.transformedListHolder.removeListChangeListener(ValueModel.VALUE, listener);
-		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		this.transformedListHolder.removeListChangeListener(ListValueModel.LIST_VALUES, listener);
+		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		this.transformedListHolder.addListChangeListener(listener);
-		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		this.transformedListHolder.removeListChangeListener(listener);
-		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(((AbstractModel) this.listHolder).hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/prefs/PreferencesCollectionValueModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/prefs/PreferencesCollectionValueModelTests.java
index b4466bef15..2c4fbecbcb 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/prefs/PreferencesCollectionValueModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/prefs/PreferencesCollectionValueModelTests.java
@@ -179,7 +179,7 @@ public class PreferencesCollectionValueModelTests extends PreferencesTestCase {
 		this.verifyAdapter(this.preferencesAdapter);
 	}
 
-	public void testGetValue() throws Exception {
+	public void testValues() throws Exception {
 		this.verifyNode(this.testNode);
 		this.verifyAdapter(this.preferencesAdapter);
 	}
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterTests.java
index 60284db5e4..0f66f85e69 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterTests.java
@@ -20,6 +20,7 @@ import javax.swing.ListModel;
 import org.eclipse.jpt.utility.internal.ClassTools;
 import org.eclipse.jpt.utility.internal.model.event.PropertyChangeEvent;
 import org.eclipse.jpt.utility.internal.model.listener.PropertyChangeListener;
+import org.eclipse.jpt.utility.internal.model.value.ListValueModel;
 import org.eclipse.jpt.utility.internal.model.value.SimpleListValueModel;
 import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
 import org.eclipse.jpt.utility.internal.model.value.ValueModel;
@@ -50,25 +51,25 @@ public class ComboBoxModelAdapterTests extends TestCase {
 
 	public void testHasListeners() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
-		SimplePropertyValueModel selectionHolder = new SimplePropertyValueModel(((ListIterator) listHolder.value()).next());
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
+		SimplePropertyValueModel selectionHolder = new SimplePropertyValueModel(((ListIterator) listHolder.values()).next());
 		assertFalse(selectionHolder.hasAnyPropertyChangeListeners(ValueModel.VALUE));
 
 		ComboBoxModel comboBoxModel = new ComboBoxModelAdapter(listHolder, selectionHolder);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(selectionHolder.hasAnyPropertyChangeListeners(ValueModel.VALUE));
 		this.verifyHasNoListeners(comboBoxModel);
 
 		SynchronizedList synchList = new SynchronizedList(comboBoxModel);
 		PropertyChangeListener selectionListener = this.buildSelectionListener();
 		selectionHolder.addPropertyChangeListener(ValueModel.VALUE, selectionListener);
-		assertTrue(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertTrue(selectionHolder.hasAnyPropertyChangeListeners(ValueModel.VALUE));
 		this.verifyHasListeners(comboBoxModel);
 
 		comboBoxModel.removeListDataListener(synchList);
 		selectionHolder.removePropertyChangeListener(ValueModel.VALUE, selectionListener);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertFalse(selectionHolder.hasAnyPropertyChangeListeners(ValueModel.VALUE));
 		this.verifyHasNoListeners(comboBoxModel);
 	}
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterUITest.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterUITest.java
index 945f9913fd..1a18dd271f 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterUITest.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ComboBoxModelAdapterUITest.java
@@ -279,7 +279,7 @@ public class ComboBoxModelAdapterUITest {
 
 	void addTen() {
 		for (int i = this.nextColorNumber; i < this.nextColorNumber + 20; i++) {
-			this.colorListHolder.addItem(this.colorListHolder.size(), "color" + i);
+			this.colorListHolder.add(this.colorListHolder.size(), "color" + i);
 		}
 		this.nextColorNumber += 20;
 	}
@@ -302,7 +302,7 @@ public class ComboBoxModelAdapterUITest {
 	void removeTen() {
 		for (int i = 0; i < 20; i++) {
 			if (this.colorListHolder.size() > 0) {
-				this.colorListHolder.removeItem(this.colorListHolder.size() - 1);
+				this.colorListHolder.remove(this.colorListHolder.size() - 1);
 			}
 		}
 	}
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ListModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ListModelAdapterTests.java
index a7eb90e405..7ea3ba5628 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ListModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/ListModelAdapterTests.java
@@ -80,17 +80,17 @@ public class ListModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compare(listModel, synchList);
 
-		listHolder.addItem(6, "tom");
-		listHolder.addItem(7, "dick");
-		listHolder.addItem(8, "harry");
-		listHolder.addItem(9, null);
+		listHolder.add(6, "tom");
+		listHolder.add(7, "dick");
+		listHolder.add(8, "harry");
+		listHolder.add(9, null);
 		assertEquals(10, synchList.size());
 		this.compare(listModel, synchList);
 
-		listHolder.removeItem(9);
-		listHolder.removeItem(8);
-		listHolder.removeItem(4);
-		listHolder.removeItem(0);
+		listHolder.remove(9);
+		listHolder.remove(8);
+		listHolder.remove(4);
+		listHolder.remove(0);
 		assertEquals(6, synchList.size());
 		this.compare(listModel, synchList);
 	}
@@ -99,7 +99,7 @@ public class ListModelAdapterTests extends TestCase {
 		SimpleListValueModel listHolder1 = this.buildListHolder();
 		ListModelAdapter listModel = new ListModelAdapter(listHolder1);
 		SynchronizedList synchList = new SynchronizedList(listModel);
-		assertTrue(listHolder1.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder1.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		assertEquals(6, synchList.size());
 		this.compare(listModel, synchList);
 
@@ -107,14 +107,14 @@ public class ListModelAdapterTests extends TestCase {
 		listModel.setModel(listHolder2);
 		assertEquals(3, synchList.size());
 		this.compare(listModel, synchList);
-		assertTrue(listHolder1.hasNoListChangeListeners(ValueModel.VALUE));
-		assertTrue(listHolder2.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder1.hasNoListChangeListeners(ListValueModel.LIST_VALUES));
+		assertTrue(listHolder2.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		listModel.setModel(new SimpleListValueModel());
 		assertEquals(0, synchList.size());
 		this.compare(listModel, synchList);
-		assertTrue(listHolder1.hasNoListChangeListeners(ValueModel.VALUE));
-		assertTrue(listHolder2.hasNoListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder1.hasNoListChangeListeners(ListValueModel.LIST_VALUES));
+		assertTrue(listHolder2.hasNoListChangeListeners(ListValueModel.LIST_VALUES));
 	}
 
 	private void compare(ListModel listModel, List list) {
@@ -176,16 +176,16 @@ public class ListModelAdapterTests extends TestCase {
 		assertEquals(6, synchList.size());
 		this.compareSort(listModel, synchList, comparator);
 
-		listHolder.addItem(0, "tom");
-		listHolder.addItem(0, "dick");
-		listHolder.addItem(0, "harry");
+		listHolder.add(0, "tom");
+		listHolder.add(0, "dick");
+		listHolder.add(0, "harry");
 		assertEquals(9, synchList.size());
 		this.compareSort(listModel, synchList, comparator);
 
-		listHolder.removeItem(8);
-		listHolder.removeItem(4);
-		listHolder.removeItem(0);
-		listHolder.removeItem(5);
+		listHolder.remove(8);
+		listHolder.remove(4);
+		listHolder.remove(0);
+		listHolder.remove(5);
 		assertEquals(5, synchList.size());
 		this.compareSort(listModel, synchList, comparator);
 	}
@@ -203,18 +203,18 @@ public class ListModelAdapterTests extends TestCase {
 
 	public void testHasListeners() throws Exception {
 		SimpleListValueModel listHolder = this.buildListHolder();
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 
 		ListModel listModel = new ListModelAdapter(listHolder);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.verifyHasNoListeners(listModel);
 
 		SynchronizedList synchList = new SynchronizedList(listModel);
-		assertTrue(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertTrue(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.verifyHasListeners(listModel);
 
 		listModel.removeListDataListener(synchList);
-		assertFalse(listHolder.hasAnyListChangeListeners(ValueModel.VALUE));
+		assertFalse(listHolder.hasAnyListChangeListeners(ListValueModel.LIST_VALUES));
 		this.verifyHasNoListeners(listModel);
 	}
 
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/PrimitiveListTreeModelTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/PrimitiveListTreeModelTests.java
index 12d1e06a95..a05f97ae48 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/PrimitiveListTreeModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/PrimitiveListTreeModelTests.java
@@ -65,7 +65,7 @@ public class PrimitiveListTreeModelTests extends TestCase {
 				return ((TestModel) this.subject).names();
 			}
 			@Override
-			public Object getItem(int index) {
+			public Object get(int index) {
 				return ((TestModel) this.subject).getName(index);
 			}
 			@Override
@@ -73,23 +73,23 @@ public class PrimitiveListTreeModelTests extends TestCase {
 				return ((TestModel) this.subject).namesSize();
 			}
 			@Override
-			public void addItem(int index, Object item) {
+			public void add(int index, Object item) {
 				((TestModel) this.subject).addName(index, (String) item);
 			}
 			@Override
-			public void addItems(int index, List items) {
+			public void addAll(int index, List items) {
 				((TestModel) this.subject).addNames(index, items);
 			}
 			@Override
-			public Object removeItem(int index) {
+			public Object remove(int index) {
 				return ((TestModel) this.subject).removeName(index);
 			}
 			@Override
-			public List removeItems(int index, int length) {
+			public List remove(int index, int length) {
 				return ((TestModel) this.subject).removeNames(index, length);
 			}
 			@Override
-			public Object replaceItem(int index, Object item) {
+			public Object replace(int index, Object item) {
 				return ((TestModel) this.subject).replaceName(index, (String) item);
 			}
 		};
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/TreeModelAdapterTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/TreeModelAdapterTests.java
index fb3ab75bb4..353133c515 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/TreeModelAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/model/value/swing/TreeModelAdapterTests.java
@@ -564,7 +564,7 @@ public class TreeModelAdapterTests extends TestCase {
 		public void dumpOn(IndentingPrintWriter writer) {
 			writer.println(this);
 			writer.indent();
-			for (Iterator stream = (Iterator) this.childrenModel.value(); stream.hasNext(); ) {
+			for (Iterator stream = (Iterator) this.childrenModel.values(); stream.hasNext(); ) {
 				((TestNode) stream.next()).dumpOn(writer);
 			}
 			writer.undent();
@@ -604,7 +604,7 @@ public class TreeModelAdapterTests extends TestCase {
 		 * testing convenience method
 		 */
 		public TestNode childNamed(String name) {
-			for (Iterator stream = (Iterator) this.childrenModel.value(); stream.hasNext(); ) {
+			for (Iterator stream = (Iterator) this.childrenModel.values(); stream.hasNext(); ) {
 				TestNode childNode = (TestNode) stream.next();
 				if (childNode.getTestModel().getName().equals(name)) {
 					return childNode;