Generalized change sets

3 files changed, 271 insertions, 56 deletions

diff --git a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/EclipseTest.java b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/EclipseTest.java
index 412a0655c..53ada45f6 100644
--- a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/EclipseTest.java
+++ b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/EclipseTest.java
@@ -381,25 +381,25 @@ public class EclipseTest extends EclipseWorkspaceTest {
 	/*
 	 * Create a test project using the currently running test case as the project name prefix
 	 */
-	protected IProject createProject(String[] strings) throws TeamException, CoreException {
+	protected IProject createProject(String[] strings) throws CoreException {
 		return createProject(getName(), strings);
 	}
 	
 	/*
 	 * Compare two projects by comparing thier providers
 	 */
-	protected void assertEquals(IProject project1, IProject project2) throws CoreException, TeamException, IOException {
+	protected void assertEquals(IProject project1, IProject project2) throws CoreException, IOException {
 		assertEquals(project1, project2, false, false);
 	}
 	
-	protected void assertEquals(IProject project1, IProject project2, boolean includeTimestamps, boolean includeTags) throws CoreException, TeamException, IOException {
+	protected void assertEquals(IProject project1, IProject project2, boolean includeTimestamps, boolean includeTags) throws CoreException, IOException {
 		assertEquals(getProvider(project1), getProvider(project2), includeTimestamps, includeTags);
 	}
 	
 	/*
 	 * Compare CVS team providers by comparing the cvs resource corresponding to the provider's project
 	 */
-	protected void assertEquals(CVSTeamProvider provider1, CVSTeamProvider provider2, boolean includeTimestamps, boolean includeTags) throws CoreException, TeamException, IOException {
+	protected void assertEquals(CVSTeamProvider provider1, CVSTeamProvider provider2, boolean includeTimestamps, boolean includeTags) throws CoreException, IOException {
 		assertEquals(Path.EMPTY, CVSWorkspaceRoot.getCVSFolderFor(provider1.getProject()), 
 			CVSWorkspaceRoot.getCVSFolderFor(provider2.getProject()), 
 			includeTimestamps, includeTags);
diff --git a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSChangeSetTests.java b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSChangeSetTests.java
index c71fdb45b..6f0ce2d31 100644
--- a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSChangeSetTests.java
+++ b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSChangeSetTests.java
@@ -10,6 +10,8 @@
  *******************************************************************************/
 package org.eclipse.team.tests.ccvs.core.subscriber;
 
+import java.io.ByteArrayInputStream;
+import java.util.*;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -17,18 +19,17 @@ import junit.framework.Test;
 
 import org.eclipse.compare.structuremergeviewer.IDiffElement;
 import org.eclipse.core.resources.*;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.swt.widgets.Display;
+import org.eclipse.core.runtime.*;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.swt.widgets.*;
 import org.eclipse.team.core.TeamException;
-import org.eclipse.team.core.subscribers.Subscriber;
+import org.eclipse.team.core.subscribers.*;
+import org.eclipse.team.core.synchronize.SyncInfo;
 import org.eclipse.team.internal.ccvs.core.CVSTag;
-import org.eclipse.team.internal.ccvs.ui.subscriber.ChangeLogDiffNode;
-import org.eclipse.team.internal.ccvs.ui.subscriber.ChangeLogModelManager;
+import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
 import org.eclipse.team.internal.ui.synchronize.*;
 import org.eclipse.team.tests.ccvs.ui.SynchronizeViewTestAdapter;
-import org.eclipse.team.ui.synchronize.ISynchronizeModelElement;
-import org.eclipse.team.ui.synchronize.ISynchronizeParticipant;
+import org.eclipse.team.ui.synchronize.*;
 import org.eclipse.ui.PartInitException;
 
 /**
@@ -51,12 +52,14 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
     private void assertIncomingChangesInSets(IFile[][] files, String[] messages) throws CoreException {
         // Get the workspace subscriber which also creates a participant and page in the sync view
         Subscriber workspaceSubscriber = getWorkspaceSubscriber();
-        enableCommitSets(workspaceSubscriber);
         refresh(workspaceSubscriber);
         ISynchronizeModelElement root = getModelRoot(workspaceSubscriber);
+        ChangeSetDiffNode[] nodes = getCheckedInChangeSetNodes(root);
+        assertNodesInViewer(workspaceSubscriber, nodes);
+        assertEquals("The number of change sets in the sync view do not match the expected number", messages.length, nodes.length);
         for (int i = 0; i < messages.length; i++) {
             String message = messages[i];
-            ChangeLogDiffNode node = getCommitSetFor(root, message);
+            ChangeSetDiffNode node = getCommitSetFor(root, message);
             assertNotNull("The commit set for '" + message + "' is not in the sync view", node);
             List filesInSet = new ArrayList();
             getFileChildren(node, filesInSet);
@@ -67,7 +70,58 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
             }
         }
     }
+
+    private void assertNodesInViewer(Subscriber workspaceSubscriber, ChangeSetDiffNode[] nodes) throws PartInitException {
+        ISynchronizeParticipant participant = SynchronizeViewTestAdapter.getParticipant(workspaceSubscriber);
+        SubscriberParticipantPage page = (SubscriberParticipantPage)SynchronizeViewTestAdapter.getSyncViewPage(participant);
+        TreeViewer viewer = (TreeViewer)page.getViewer();
+        Tree tree = viewer.getTree();
+        List nodeList = new ArrayList();
+        nodeList.addAll(Arrays.asList(nodes));
+        TreeItem[] items = tree.getItems();
+        removeTreeItemsFromList(nodeList, items);
+        assertTrue("Not all nodes are visible in the view", nodeList.isEmpty());
+    }
+
+    private void removeTreeItemsFromList(List nodeList, TreeItem[] items) {
+        for (int i = 0; i < items.length; i++) {
+            TreeItem item = items[i];
+            nodeList.remove(item.getData());
+            TreeItem[] children = item.getItems();
+            removeTreeItemsFromList(nodeList, children);
+        }
+    }
+
+    private ChangeSetDiffNode[] getCheckedInChangeSetNodes(ISynchronizeModelElement root) {
+        List result = new ArrayList();
+        IDiffElement[] children = root.getChildren();
+        for (int i = 0; i < children.length; i++) {
+            IDiffElement element = children[i];
+            if (element instanceof ChangeSetDiffNode) {
+                ChangeSetDiffNode node = (ChangeSetDiffNode)element;
+                if (node.getSet() instanceof CheckedInChangeSet) {
+                    result.add(node);
+                }
+            }
+        }
+        return (ChangeSetDiffNode[]) result.toArray(new ChangeSetDiffNode[result.size()]);
+    }
     
+    private ChangeSetDiffNode[] getActiveChangeSetNodes(ISynchronizeModelElement root) {
+        List result = new ArrayList();
+        IDiffElement[] children = root.getChildren();
+        for (int i = 0; i < children.length; i++) {
+            IDiffElement element = children[i];
+            if (element instanceof ChangeSetDiffNode) {
+                ChangeSetDiffNode node = (ChangeSetDiffNode)element;
+                if (node.getSet() instanceof ActiveChangeSet) {
+                    result.add(node);
+                }
+            }
+        }
+        return (ChangeSetDiffNode[]) result.toArray(new ChangeSetDiffNode[result.size()]);
+    }
+
     /**
      * Adds IFiles to the list
      */
@@ -84,13 +138,13 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
         return;
     }
 
-    private ChangeLogDiffNode getCommitSetFor(ISynchronizeModelElement root, String message) {
+    private ChangeSetDiffNode getCommitSetFor(ISynchronizeModelElement root, String message) {
         IDiffElement[] children = root.getChildren();
         for (int i = 0; i < children.length; i++) {
             IDiffElement element = children[i];
-            if (element instanceof ChangeLogDiffNode) {
-                ChangeLogDiffNode node = (ChangeLogDiffNode)element;
-                if (node.getComment().getComment().equals(message)) {
+            if (element instanceof ChangeSetDiffNode) {
+                ChangeSetDiffNode node = (ChangeSetDiffNode)element;
+                if (node.getSet().getComment().equals(message)) {
                     return node;
                 }
             }
@@ -102,13 +156,28 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
         workspaceSubscriber.refresh(workspaceSubscriber.roots(), IResource.DEPTH_INFINITE, DEFAULT_MONITOR);
     }
 
-    private void enableCommitSets(Subscriber workspaceSubscriber) throws PartInitException {
+    private void enableChangeSets(Subscriber workspaceSubscriber) throws PartInitException {
         ISynchronizeParticipant participant = SynchronizeViewTestAdapter.getParticipant(workspaceSubscriber);
         SubscriberParticipantPage page = (SubscriberParticipantPage)SynchronizeViewTestAdapter.getSyncViewPage(participant);
-        ChangeLogModelManager manager = (ChangeLogModelManager)page.getConfiguration().getProperty(SynchronizePageConfiguration.P_MODEL_MANAGER);
+        ChangeSetModelManager manager = (ChangeSetModelManager)page.getConfiguration().getProperty(SynchronizePageConfiguration.P_MODEL_MANAGER);
         manager.setCommitSetsEnabled(true);
+        page.getConfiguration().setMode(ISynchronizePageConfiguration.BOTH_MODE);
     }
 
+    private void enableCheckedInChangeSets(Subscriber workspaceSubscriber) throws PartInitException {
+        enableChangeSets(workspaceSubscriber);
+        ISynchronizeParticipant participant = SynchronizeViewTestAdapter.getParticipant(workspaceSubscriber);
+        SubscriberParticipantPage page = (SubscriberParticipantPage)SynchronizeViewTestAdapter.getSyncViewPage(participant);
+        page.getConfiguration().setMode(ISynchronizePageConfiguration.INCOMING_MODE);
+    }
+    
+    private void enableActiveChangeSets(Subscriber workspaceSubscriber) throws PartInitException {
+        enableChangeSets(workspaceSubscriber);
+        ISynchronizeParticipant participant = SynchronizeViewTestAdapter.getParticipant(workspaceSubscriber);
+        SubscriberParticipantPage page = (SubscriberParticipantPage)SynchronizeViewTestAdapter.getSyncViewPage(participant);
+        page.getConfiguration().setMode(ISynchronizePageConfiguration.OUTGOING_MODE);
+    }
+    
     /*
      * Wait until all the background handlers have settled and then return the root element in the sync view
      */
@@ -116,9 +185,9 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
         SynchronizeViewTestAdapter.getCollector(workspaceSubscriber);
         ISynchronizeParticipant participant = SynchronizeViewTestAdapter.getParticipant(workspaceSubscriber);
         SubscriberParticipantPage page = (SubscriberParticipantPage)SynchronizeViewTestAdapter.getSyncViewPage(participant);
-        ChangeLogModelManager manager = (ChangeLogModelManager)page.getConfiguration().getProperty(SynchronizePageConfiguration.P_MODEL_MANAGER);
+        ChangeSetModelManager manager = (ChangeSetModelManager)page.getConfiguration().getProperty(SynchronizePageConfiguration.P_MODEL_MANAGER);
         AbstractSynchronizeModelProvider provider = (AbstractSynchronizeModelProvider)manager.getActiveModelProvider();
-        provider.waitForUpdateHandler(new IProgressMonitor() {
+        provider.waitUntilDone(new IProgressMonitor() {
 			public void beginTask(String name, int totalWork) {
 			}
 			public void done() {
@@ -141,7 +210,131 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
         return provider.getModelRoot();
     }
 
+    private SubscriberChangeSetCollector getActiveChangeSetManager() {
+        return CVSUIPlugin.getPlugin().getChangeSetManager();
+    }
+    
+    /*
+     * Assert that the given resources make up the given set both directly
+     * and by what is displayed in the sync view.
+     */
+    private void assertInActiveSet(IResource[] resources, ActiveChangeSet set) throws CoreException {
+        assertResourcesAreTheSame(resources, set.getResources());
+        ISynchronizeModelElement root = getModelRoot(getActiveChangeSetManager().getSubscriber());
+        ChangeSetDiffNode node = getChangeSetNodeFor(root, set);
+        assertNotNull("Change set " + set.getTitle() + " did not appear in the sync view", node);
+        IResource[] outOfSync = getOutOfSyncResources(node);
+        assertResourcesAreTheSame(resources, outOfSync);
+        // Assert that all active sets are visible in the view
+        ChangeSet[] sets = getActiveChangeSetManager().getSets();
+        for (int i = 0; i < sets.length; i++) {
+            ChangeSet changeSet = sets[i];
+            node = getChangeSetNodeFor(root, changeSet);
+            assertNotNull("The node for set " + set.getName() + " is not in the view", node);
+            
+        }
+        ChangeSetDiffNode[] nodes = getActiveChangeSetNodes(root);
+        assertNodesInViewer(getWorkspaceSubscriber(), nodes);
+    }
+    
+    private ChangeSetDiffNode getChangeSetNodeFor(ISynchronizeModelElement root, ChangeSet set) {
+        IDiffElement[] children = root.getChildren();
+        for (int i = 0; i < children.length; i++) {
+            IDiffElement element = children[i];
+            if (element instanceof ChangeSetDiffNode) {
+                ChangeSetDiffNode node = (ChangeSetDiffNode)element;
+                if (node.getSet() == set) {
+                    return node;
+                }
+            }
+        }
+        return null;
+    }
+
+    private IResource[] getOutOfSyncResources(ISynchronizeModelElement element) {
+        ArrayList arrayList = new ArrayList();
+        getOutOfSync(element, arrayList);
+        SyncInfo[] infos = (SyncInfo[]) arrayList.toArray(new SyncInfo[arrayList.size()]);
+        IResource[] resources = getResources(infos);
+        return resources;
+    }
+
+    private IResource[] getResources(SyncInfo[] infos) {
+        IResource[] resources = new IResource[infos.length];
+        for (int i = 0; i < resources.length; i++) {
+            resources[i] = infos[i].getLocal();
+        }
+        return resources;
+    }
+
+    private void getOutOfSync(ISynchronizeModelElement node, List list) {
+        SyncInfo info = getSyncInfo(node);
+        if (info != null && info.getKind() != SyncInfo.IN_SYNC) {
+            list.add(info);
+        }
+        IDiffElement[] children = node.getChildren();
+        for (int i = 0; i < children.length; i++) {
+            IDiffElement child = children[i];
+            getOutOfSync((ISynchronizeModelElement)child, list);
+        }
+        return;
+    }
+    
+    private SyncInfo getSyncInfo(ISynchronizeModelElement node) {
+        if (node instanceof IAdaptable) {
+            return (SyncInfo)((IAdaptable)node).getAdapter(SyncInfo.class);
+        }
+        return null;
+    }
+
+    private void assertResourcesAreTheSame(IResource[] resources1, IResource[] resources2) {
+        assertEquals("The number of resources do not match the expected number", resources1.length, resources2.length);
+        for (int i = 0; i < resources1.length; i++) {
+            IResource resource = resources1[i];
+            boolean found = false;
+            for (int j = 0; j < resources2.length; j++) {
+                IResource resource2 = resources2[j];
+                if (resource2.equals(resource)) {
+                    found = true;
+                    break;
+                }
+            }
+            assertTrue("Expected resource " + resource.getFullPath().toString() + " was not presebt", found);
+        }
+    }
+
+    /*
+     * Assert that the given resources make up the root set
+     * displayed in the sync view. The root set is those 
+     * resources that are not part of an active change set.
+     */
+    private void assertInRootSet(IResource[] resources) throws CoreException {
+        ISynchronizeModelElement[] nodes = getNonChangeSetRoots(getModelRoot(getActiveChangeSetManager().getSubscriber()));
+        List list = new ArrayList();
+        for (int i = 0; i < nodes.length; i++) {
+            ISynchronizeModelElement element = nodes[i];
+            getOutOfSync(element, list);
+        }
+        IResource[] outOfSync = getResources((SyncInfo[]) list.toArray(new SyncInfo[list.size()]));
+        assertResourcesAreTheSame(resources, outOfSync);
+        
+    }
+    
+    private ISynchronizeModelElement[] getNonChangeSetRoots(ISynchronizeModelElement modelRoot) {
+        List result = new ArrayList();
+        IDiffElement[] children = modelRoot.getChildren();
+        for (int i = 0; i < children.length; i++) {
+            IDiffElement element = children[i];
+            if (!(element instanceof ChangeSetDiffNode)) {
+                result.add(element);
+            }
+        }
+        return (ISynchronizeModelElement[]) result.toArray(new ISynchronizeModelElement[result.size()]);
+    }
+
     public void testSimpleCommit() throws CoreException {
+        enableCheckedInChangeSets(getWorkspaceSubscriber());
+        
 	    IProject project = createProject(new String[] { "file1.txt", "file2.txt", "folder1/", "folder1/a.txt", "folder1/b.txt"});
 	    
 	    // Modify a file in a copy
@@ -170,6 +363,36 @@ public class CVSChangeSetTests extends CVSSyncSubscriberTest {
 	            { project.getFile("folder1/a.txt") },
 	            { project.getFile("file2.txt")}
 	            }, new String[] {message1, message2, message3});
+	    
+	    // Now commit the files in one of the sets and ensure it is removed from the view
+	    updateResources(new IResource[] { project.getFile("file1.txt")}, false);
+	    assertIncomingChangesInSets(new IFile[][] {
+	            { project.getFile("folder1/a.txt") },
+	            { project.getFile("file2.txt")}
+	            }, new String[] {message2, message3});
 	}
 	
+    public void testSimpleActiveChangeSet() throws CoreException {
+        IProject project = createProject(new String[] { "file1.txt", "file2.txt", "folder1/", "folder1/a.txt", "folder1/b.txt"});
+        // Enable Change Sets
+        enableActiveChangeSets(getWorkspaceSubscriber());
+	    // Add a folder and file
+	    IFolder newFolder = project.getFolder("folder2");
+        newFolder.create(false, true, null);
+        IFile newFile = newFolder.getFile("file.txt");
+        newFile.create(new ByteArrayInputStream("Hi There".getBytes()), false, null);
+        // Create an active commit set and assert that it appears in the sync view
+        SubscriberChangeSetCollector manager = getActiveChangeSetManager();
+        ActiveChangeSet set = manager.createSet("test", new SyncInfo[0]);
+        manager.add(set);
+        assertInActiveSet(new IResource[] { }, set);
+        assertInRootSet(new IResource[] {newFolder, newFile});
+        // Add the new file to the set and assert that the file is in the set and the folder is still at the root
+        set.add(new IResource[] { newFile });
+        assertInActiveSet(new IResource[] { newFile }, set);
+        assertInRootSet(new IResource[] {newFolder });
+	    // Add the folder to the set
+        set.add(new IResource[] { newFolder });
+        assertInActiveSet(new IResource[] { newFolder, newFile }, set);
+    }
 }
diff --git a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/CommitSetTests.java b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/CommitSetTests.java
index ee2249201..bc47dd615 100644
--- a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/CommitSetTests.java
+++ b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/CommitSetTests.java
@@ -11,21 +11,18 @@
 package org.eclipse.team.tests.ccvs.ui;
 
 import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.List;
 
 import junit.framework.Test;
 
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jface.util.PropertyChangeEvent;
+import org.eclipse.swt.widgets.Display;
 import org.eclipse.team.core.TeamException;
+import org.eclipse.team.core.subscribers.*;
 import org.eclipse.team.internal.ccvs.core.CVSException;
-import org.eclipse.team.internal.ccvs.ui.subscriber.*;
-import org.eclipse.team.internal.ccvs.ui.subscriber.CommitSet;
-import org.eclipse.team.internal.ccvs.ui.subscriber.CommitSetManager;
+import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
 import org.eclipse.team.tests.ccvs.core.EclipseTest;
 
 /**
@@ -35,22 +32,22 @@ public class CommitSetTests extends EclipseTest {
 
 	private List addedSets = new ArrayList();
 	private List removedSets = new ArrayList();
-	private ICommitSetChangeListener listener = new ICommitSetChangeListener() {
-        public void setAdded(CommitSet set) {
+	private IChangeSetChangeListener listener = new IChangeSetChangeListener() {
+        public void setAdded(ChangeSet set) {
             addedSets.add(set);
         }
-        public void setRemoved(CommitSet set) {
+        public void setRemoved(ChangeSet set) {
             removedSets.add(set);
         }
-        public void titleChanged(CommitSet set) {
+        public void nameChanged(ChangeSet set) {
             // TODO Auto-generated method stub
 
         }
-        public void filesChanged(CommitSet set, IFile[] files) {
+        public void defaultSetChanged(ChangeSet oldDefault, ChangeSet set) {
             // TODO Auto-generated method stub
-
+            
         }
-        public void propertyChange(PropertyChangeEvent event) {
+        public void resourcesChanged(ChangeSet set, IResource[] resources) {
             // TODO Auto-generated method stub
             
         }
@@ -75,11 +72,11 @@ public class CommitSetTests extends EclipseTest {
      * @return the newly create commit set
      * @throws TeamException
      */
-    protected CommitSet createCommitSet(String title, IFile[] files, boolean manageSet) throws TeamException {
+    protected ActiveChangeSet createCommitSet(String title, IFile[] files, boolean manageSet) throws TeamException {
         assertIsModified(getName(), files);
-        CommitSetManager manager = CommitSetManager.getInstance();
-        CommitSet set = manager.createCommitSet(title, files);
-        assertEquals("Not all files were asdded to the set", files.length, set.getFiles().length);
+        SubscriberChangeSetCollector manager = CVSUIPlugin.getPlugin().getChangeSetManager();
+        ActiveChangeSet set = manager.createSet(title, files);
+        assertEquals("Not all files were asdded to the set", files.length, set.getResources().length);
         if (manageSet) {
 	        manager.add(set);
 	        waitForSetAddedEvent(set);
@@ -94,26 +91,20 @@ public class CommitSetTests extends EclipseTest {
      * @param set the commit set
      * @throws CVSException
      */
-    protected void commit(CommitSet set) throws CVSException {
+    protected void commit(ActiveChangeSet set) throws CoreException {
         boolean isManaged = setIsManaged(set);
-        try {
-            set.commit(null /* no workbench part */, DEFAULT_MONITOR);
-        } catch (InvocationTargetException e) {
-            throw CVSException.wrapException(e);
-        } catch (InterruptedException e) {
-            fail("The commit was interupted");
-        }
+        commitResources(set.getResources(), IResource.DEPTH_ZERO);
         if (isManaged) {
 	        // Committing the set should remove it from the manager
             waitForSetRemovedEvent(set);
         }
     }
     
-    private boolean setIsManaged(CommitSet set) {
-        return CommitSetManager.getInstance().contains(set);
+    private boolean setIsManaged(ActiveChangeSet set) {
+        return CVSUIPlugin.getPlugin().getChangeSetManager().contains(set);
     }
 
-    private void waitForSetAddedEvent(CommitSet set) {
+    private void waitForSetAddedEvent(ActiveChangeSet set) {
         int count = 0;
         while (count < 5) {
 	        if (addedSets.contains(set)) {
@@ -130,7 +121,7 @@ public class CommitSetTests extends EclipseTest {
         fail("Did not receive expected set added event");
     }
 
-    private void waitForSetRemovedEvent(CommitSet set) {
+    private void waitForSetRemovedEvent(ActiveChangeSet set) {
         int count = 0;
         while (count < 5) {
 	        if (removedSets.contains(set)) {
@@ -138,6 +129,7 @@ public class CommitSetTests extends EclipseTest {
 	            return;
 	        }
 	        try {
+                while (Display.getCurrent().readAndDispatch()) {}
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // keep going
@@ -152,7 +144,7 @@ public class CommitSetTests extends EclipseTest {
      */
     protected void setUp() throws Exception {
         super.setUp();
-        CommitSetManager.getInstance().addListener(listener);
+        CVSUIPlugin.getPlugin().getChangeSetManager().addListener(listener);
     }
     
     /* (non-Javadoc)
@@ -160,7 +152,7 @@ public class CommitSetTests extends EclipseTest {
      */
     protected void tearDown() throws Exception {
         super.tearDown();
-        CommitSetManager.getInstance().removeListener(listener);
+        CVSUIPlugin.getPlugin().getChangeSetManager().removeListener(listener);
     }
     
     /**
@@ -179,7 +171,7 @@ public class CommitSetTests extends EclipseTest {
                 project.getFile("changed.txt"), 
                 project.getFile("deleted.txt"),
                 project.getFile("added.txt")};
-        CommitSet set = createCommitSet("testSimpleCommit", files, false /* do not manage the set */);
+        ActiveChangeSet set = createCommitSet("testSimpleCommit", files, false /* do not manage the set */);
         commit(set);
         assertLocalStateEqualsRemote(project);
     }
@@ -201,7 +193,7 @@ public class CommitSetTests extends EclipseTest {
                 project.getFile("changed.txt"), 
                 project.getFile("deleted.txt"),
                 project.getFile("added.txt")};
-        CommitSet set = createCommitSet("testSimpleCommit", files, true /* manage the set */);
+        ActiveChangeSet set = createCommitSet("testSimpleCommit", files, true /* manage the set */);
         commit(set);
         assertLocalStateEqualsRemote(project);
     }