Sync view tests now work with an event processing job.

7 files changed, 181 insertions, 118 deletions

diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/IPreferenceIds.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/IPreferenceIds.java
index d7c1497fd..42ae2f5f9 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/IPreferenceIds.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/IPreferenceIds.java
@@ -26,6 +26,4 @@ public interface IPreferenceIds {
 	public static final String SYNCVIEW_VIEW_TYPE = PREFIX + "view_type"; //$NON-NLS-1$
 	public static final String SYNCVIEW_VIEW_TABLESORT = PREFIX + "table_column_sort"; //$NON-NLS-1$
 	public static final String SYNCVIEW_VIEW_TABLESORT_REVERSED = PREFIX + "table_column_sort_reversed"; //$NON-NLS-1$
-	
-	public static final String TESTING_SYNCVIEW = PREFIX + "testing_syncview"; //$NON-NLS-1$
 }
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/TeamUIPlugin.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/TeamUIPlugin.java
index 1c99f84f0..fcb3d00bd 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/TeamUIPlugin.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/TeamUIPlugin.java
@@ -149,7 +149,6 @@ public class TeamUIPlugin extends AbstractUIPlugin implements IPropertyChangeLis
 		store.setDefault(IPreferenceIds.SYNCVIEW_COMPRESS_FOLDERS, true);
 		store.setDefault(IPreferenceIds.SYNCVIEW_VIEW_TABLESORT, SyncViewerTableSorter.COL_NAME);
 		store.setDefault(IPreferenceIds.SYNCVIEW_VIEW_TABLESORT_REVERSED, false);
-		store.setDefault(IPreferenceIds.TESTING_SYNCVIEW, false);
 		store.setDefault(IPreferenceIds.SYNCVIEW_DEFAULT_PERSPECTIVE, "org.eclipse.team.internal.ui.sync.views.TeamSynchronizingPerspective"); //$NON-NLS-1$
 	}
 	
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberEventHandler.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberEventHandler.java
index 746eb9785..6280ff9b9 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberEventHandler.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberEventHandler.java
@@ -18,12 +18,10 @@ import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.team.core.TeamException;
 import org.eclipse.team.core.subscribers.SyncInfo;
 import org.eclipse.team.internal.core.ExceptionCollector;
-import org.eclipse.team.internal.ui.IPreferenceIds;
 import org.eclipse.team.internal.ui.Policy;
 import org.eclipse.team.internal.ui.TeamUIPlugin;
 
@@ -40,23 +38,23 @@ import org.eclipse.team.internal.ui.TeamUIPlugin;
 public class SubscriberEventHandler {
 	// The number of events to process before feeding into the set.
 	private static final int NOTIFICATION_BATCHING_NUMBER = 10;
-	
+
 	// The set that receives notification when the resource synchronization state
 	// has been calculated by the job.
 	private SyncSetInputFromSubscriber set;
 
-	 // Events that need to be processed
-	 private List awaitingProcessing = new ArrayList();
-	 
-	 // Use to shutdown the job
-	 private boolean shutdown = false;
+	// Events that need to be processed
+	private List awaitingProcessing = new ArrayList();
+
+	// Use to shutdown the job
+	private boolean shutdown = false;
 
 	// The job that runs when events need to be processed
-	 Job eventHandlerJob;
-	 
+	Job eventHandlerJob;
+
 	// manages exceptions
 	private ExceptionCollector errors;
-	
+
 	/**
 	 * Internal resource synchronization event. Can contain a result.
 	 */
@@ -68,22 +66,26 @@ public class SubscriberEventHandler {
 		int type;
 		int depth;
 		SyncInfo result;
-		
+
 		Event(IResource resource, int type, int depth) {
 			this.resource = resource;
 			this.type = type;
 			this.depth = depth;
-		}		
-		public Event(IResource resource, int type, int depth, SyncInfo result) {
+		}
+		public Event(
+			IResource resource,
+			int type,
+			int depth,
+			SyncInfo result) {
 			this(resource, type, depth);
 			this.result = result;
 		}
 		public int getDepth() {
 			return depth;
-		}		
+		}
 		public IResource getResource() {
 			return resource;
-		}		
+		}
 		public int getType() {
 			return type;
 		}
@@ -98,21 +100,23 @@ public class SubscriberEventHandler {
 	 */
 	public SubscriberEventHandler(SyncSetInputFromSubscriber set) {
 		this.set = set;
-		errors = new ExceptionCollector(Policy.bind("SubscriberEventHandler.errors"), TeamUIPlugin.ID, IStatus.ERROR, null /* don't log */); //$NON-NLS-1$
+		errors =
+			new ExceptionCollector(
+				Policy.bind("SubscriberEventHandler.errors"),
+				TeamUIPlugin.ID,
+				IStatus.ERROR,
+				null /* don't log */
+		); //$NON-NLS-1$
 		reset(Event.INITIALIZE);
 		createEventHandlingJob();
-		schedule();		
+		schedule();
 	}
 	/**
 	 * Schedule the job or process the events now.
 	 */
 	public void schedule() {
-		if(TeamUIPlugin.getPlugin().getPreferenceStore().getBoolean(IPreferenceIds.TESTING_SYNCVIEW)) {			
-			processEvents(new NullProgressMonitor());
-		} else {
-			eventHandlerJob.schedule();
-		}
-	}	
+		eventHandlerJob.schedule();
+	}
 	/**
 	 * Initialize all resources for the subscriber associated with the set. This will basically recalculate
 	 * all synchronization information for the subscriber.
@@ -120,8 +124,8 @@ public class SubscriberEventHandler {
 	 * @param depth
 	 */
 	public void initialize() {
-		reset(Event.CHANGE);		
-	}	
+		reset(Event.CHANGE);
+	}
 	/**
 	 * Called by a client to indicate that a resource has changed and its synchronization state
 	 * should be recalculated.  
@@ -130,120 +134,155 @@ public class SubscriberEventHandler {
 	 */
 	public void change(IResource resource, int depth) {
 		queueEvent(new Event(resource, Event.CHANGE, depth));
-	}	
+	}
 	/**
 	 * Called by a client to indicate that a resource has been removed and should be removed. The
 	 * removal will propagate to the set.
 	 * @param resource the resource that was removed
 	 */
 	public void remove(IResource resource) {
-		queueEvent(new Event(resource, Event.REMOVAL, IResource.DEPTH_INFINITE));
-	}	
-	 /**
-	  * Queue the event and start the job if it's not already doing work.
-	  */
-	 synchronized private void queueEvent(Event event) {
-		 awaitingProcessing.add(event);
-		 if (shutdown || eventHandlerJob == null || eventHandlerJob.getState() != Job.NONE)
+		queueEvent(
+			new Event(resource, Event.REMOVAL, IResource.DEPTH_INFINITE));
+	}
+	/**
+	 * Queue the event and start the job if it's not already doing work.
+	 */
+	synchronized private void queueEvent(Event event) {
+		awaitingProcessing.add(event);
+		if (shutdown
+			|| eventHandlerJob == null
+			|| eventHandlerJob.getState() != Job.NONE)
 			return;
-		 else {
+		else {
 			schedule();
-		 }
-	 }	
+		}
+	}
 	/**
-	  * Shutdown the event handler.
-	  */
-	 void shutdown() {
-	 	shutdown = true;
+	 * Returns the events handler job.
+	 * @return the job that calculates the synchronization state for a subscriber
+	 */
+	public Job getEventHandlerJob() {
+		return eventHandlerJob;
+	}
+	/**
+	 * Shutdown the event handler.
+	 */
+	void shutdown() {
+		shutdown = true;
 		eventHandlerJob.cancel();
-	 }
-	 /**
-	  * Get the next resource to be calculated.
-	  * @return Event to be processed
-	  */
-	 synchronized Event nextElement() {
-		 if (shutdown || awaitingProcessing.isEmpty()) {
-			 return null;
-		 }
-		 return  (Event)awaitingProcessing.remove(0);
-	 }
-
-	 /**
-	  * Create the job used for processing the events in the queue. The job stops working when
-	  * the queue is empty.
-	  */
-	 private void createEventHandlingJob() {
-			 eventHandlerJob = new Job(Policy.bind("SubscriberEventHandler.jobName")) { //$NON-NLS-1$	
-			 public IStatus run(IProgressMonitor monitor) {				
+	}
+	/**
+	 * Get the next resource to be calculated.
+	 * @return Event to be processed
+	 */
+	synchronized Event nextElement() {
+		if (shutdown || awaitingProcessing.isEmpty()) {
+			return null;
+		}
+		return (Event) awaitingProcessing.remove(0);
+	}
+	/**
+	 * Create the job used for processing the events in the queue. The job stops working when
+	 * the queue is empty.
+	 */
+	private void createEventHandlingJob() {
+		eventHandlerJob = new Job(Policy.bind("SubscriberEventHandler.jobName")) {//$NON-NLS-1$	
+		public IStatus run(IProgressMonitor monitor) {
 				return processEvents(monitor);
-			 }
-		 };
+			}
+		};
 		eventHandlerJob.setPriority(Job.SHORT);
 		eventHandlerJob.setSystem(true);
-	 }
-	 /**
-	  * Process events from the events queue and dispatch results. 
-	  */
-	private IStatus processEvents(IProgressMonitor monitor) {		
-		List resultCache = new ArrayList();				
-		Event event;				
+	}
+	/**
+	 * Process events from the events queue and dispatch results. 
+	 */
+	private IStatus processEvents(IProgressMonitor monitor) {
+		List resultCache = new ArrayList();
+		Event event;
 		errors.clear();
 		try {
 			monitor.beginTask(null, 100); //$NON-NLS-1$
-					
-			while ((event = nextElement()) != null) {			 	
+
+			while ((event = nextElement()) != null) {
 				// Cancellation is dangerous because this will leave the sync info in a bad state.
 				// Purposely not checking -				 	
 				try {
 					int type = event.getType();
-					switch(type) {
-						case Event.REMOVAL : 
+					switch (type) {
+						case Event.REMOVAL :
 							resultCache.add(event);
 							break;
 						case Event.CHANGE :
 							List results = new ArrayList();
-							collect(event.getResource(), event.getDepth(), monitor, results);
+							collect(
+								event.getResource(),
+								event.getDepth(),
+								monitor,
+								results);
 							resultCache.addAll(results);
 							break;
 						case Event.INITIALIZE :
-							Event[] events = getAllOutOfSync(new IResource[] {event.getResource()}, event.getDepth(), monitor);
+							Event[] events =
+								getAllOutOfSync(
+									new IResource[] { event.getResource()},
+									event.getDepth(),
+									monitor);
 							resultCache.addAll(Arrays.asList(events));
-							break;				 										
+							break;
 					}
 				} catch (TeamException e) {
 					// handle exception but keep going
 					errors.handleException(e);
 				}
-						 	
-				if (awaitingProcessing.isEmpty() || resultCache.size() > NOTIFICATION_BATCHING_NUMBER) {
-					dispatchEvents((Event[])resultCache.toArray(new Event[resultCache.size()]));
+
+				if (awaitingProcessing.isEmpty()
+					|| resultCache.size() > NOTIFICATION_BATCHING_NUMBER) {
+					dispatchEvents(
+						(Event[]) resultCache.toArray(
+							new Event[resultCache.size()]));
 					resultCache.clear();
-				}			
+				}
 			}
 		} finally {
 			monitor.done();
 		}
 		return errors.getStatus();
-	}	 
+	}
 	/**
 	 * Collect the calculated synchronization information for the given resource at the given depth. The
 	 * results are added to the provided list.
 	 */
-	private void collect(IResource resource, int depth, IProgressMonitor monitor, List results) throws TeamException {
-		
-		if(resource.getType() != IResource.FILE && depth != IResource.DEPTH_ZERO) {
-			IResource[] members = set.getSubscriber().members((IContainer) resource);
+	private void collect(
+		IResource resource,
+		int depth,
+		IProgressMonitor monitor,
+		List results)
+		throws TeamException {
+
+		if (resource.getType() != IResource.FILE
+			&& depth != IResource.DEPTH_ZERO) {
+			IResource[] members =
+				set.getSubscriber().members((IContainer) resource);
 			for (int i = 0; i < members.length; i++) {
-				collect(members[i], depth == IResource.DEPTH_INFINITE ? IResource.DEPTH_INFINITE : IResource.DEPTH_ZERO, monitor, results);
+				collect(
+					members[i],
+					depth == IResource.DEPTH_INFINITE
+						? IResource.DEPTH_INFINITE
+						: IResource.DEPTH_ZERO,
+					monitor,
+					results);
 			}
 		}
-		
+
 		SyncInfo info = set.getSubscriber().getSyncInfo(resource, monitor);
 		// resource is no longer under the subscriber control
 		if (info == null) {
-			results.add(new Event(resource, Event.REMOVAL, IResource.DEPTH_ZERO));
-		} else { 
-			results.add(new Event(resource, Event.CHANGE, IResource.DEPTH_ZERO, info));
+			results.add(
+				new Event(resource, Event.REMOVAL, IResource.DEPTH_ZERO));
+		} else {
+			results.add(
+				new Event(resource, Event.CHANGE, IResource.DEPTH_ZERO, info));
 		}
 	}
 	/**
@@ -255,28 +294,38 @@ public class SubscriberEventHandler {
 	 * @return Event[] the change events
 	 * @throws TeamException
 	 */
-	private Event[] getAllOutOfSync(IResource[] resources, int depth, IProgressMonitor monitor) throws TeamException {		
-		SyncInfo[] infos = set.getSubscriber().getAllOutOfSync(resources, depth, monitor);
-		
+	private Event[] getAllOutOfSync(
+		IResource[] resources,
+		int depth,
+		IProgressMonitor monitor)
+		throws TeamException {
+		SyncInfo[] infos =
+			set.getSubscriber().getAllOutOfSync(resources, depth, monitor);
+
 		// The subscriber hasn't cached out-of-sync resources. We will have to
 		// traverse all resources and calculate their state. 
-		if(infos == null) {
+		if (infos == null) {
 			List events = new ArrayList();
 			for (int i = 0; i < resources.length; i++) {
-				collect(resources[i], IResource.DEPTH_INFINITE, monitor, events);
+				collect(
+					resources[i],
+					IResource.DEPTH_INFINITE,
+					monitor,
+					events);
 			}
 			return (Event[]) events.toArray(new Event[events.size()]);
-		// The subscriber has returned the list of out-of-sync resources.
+			// The subscriber has returned the list of out-of-sync resources.
 		} else {
 			Event[] events = new Event[infos.length];
 			for (int i = 0; i < infos.length; i++) {
 				SyncInfo info = infos[i];
-				events[i] = new Event(info.getLocal(), Event.CHANGE, depth, info);
+				events[i] =
+					new Event(info.getLocal(), Event.CHANGE, depth, info);
 			}
 			return events;
-		}		
+		}
 	}
-	
+
 	/**
 	 * Feed the given events to the set. The appropriate method on the set is called
 	 * for each event type. 
@@ -287,12 +336,12 @@ public class SubscriberEventHandler {
 		set.getSyncSet().beginInput();
 		for (int i = 0; i < events.length; i++) {
 			Event event = events[i];
-			switch(event.getType()) {
-				case Event.CHANGE : 
+			switch (event.getType()) {
+				case Event.CHANGE :
 					set.collect(event.getResult());
 					break;
 				case Event.REMOVAL :
-					if(event.getDepth() == IResource.DEPTH_INFINITE) {
+					if (event.getDepth() == IResource.DEPTH_INFINITE) {
 						set.getSyncSet().removeAllChildren(event.getResource());
 					} else {
 						set.remove(event.getResource());
@@ -305,13 +354,13 @@ public class SubscriberEventHandler {
 	/**
 	 * Initialize all resources for the subscriber associated with the set. This will basically recalculate
 	 * all synchronization information for the subscriber.
-	 * @param resource
-	 * @param depth
+	 * @param type can be Event.CHANGE to recalculate all states or Event.INITIALIZE to perform the
+	 *   optimized recalculation if supported by the subscriber.
 	 */
 	private void reset(int type) {
-		IResource[] resources = set.getSubscriber().roots(); 
+		IResource[] resources = set.getSubscriber().roots();
 		for (int i = 0; i < resources.length; i++) {
-			queueEvent(new Event(resources[i], type, IResource.DEPTH_INFINITE));			
+			queueEvent(new Event(resources[i], type, IResource.DEPTH_INFINITE));
 		}
-	}	
+	}
 }
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberInput.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberInput.java
index fa1561caa..95864092f 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberInput.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/sync/sets/SubscriberInput.java
@@ -87,6 +87,10 @@ public class SubscriberInput implements IPropertyChangeListener, ITeamResourceCh
 		return workingRootsSet.getSyncSet();
 	}
 
+	public SubscriberEventHandler getEventHandler() {
+		return eventHandler;
+	}
+
 	public void setFilter(SyncInfoFilter filter, IProgressMonitor monitor) throws TeamException {
 		filteredSyncSet.setFilter(filter);
 		filteredSyncSet.reset(monitor);
diff --git a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSSyncSubscriberTest.java b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSSyncSubscriberTest.java
index b3d084dda..ca4fe3318 100644
--- a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSSyncSubscriberTest.java
+++ b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/subscriber/CVSSyncSubscriberTest.java
@@ -226,8 +226,6 @@ public abstract class CVSSyncSubscriberTest extends EclipseTest {
 	}
 
 	protected void assertProjectRemoved(TeamSubscriber subscriber, IProject project) throws TeamException, InterruptedException {
-		// wait for events to flow
-		Thread.sleep(1000);
 		getSyncInfoSource().assertProjectRemoved(subscriber, project);
 	}
 }
diff --git a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/AllTestsSynchronizeView.java b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/AllTestsSynchronizeView.java
index a38c69c5f..e292bdc34 100644
--- a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/AllTestsSynchronizeView.java
+++ b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/AllTestsSynchronizeView.java
@@ -13,8 +13,6 @@ package org.eclipse.team.tests.ccvs.ui.sync;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
-import org.eclipse.team.internal.ui.IPreferenceIds;
-import org.eclipse.team.internal.ui.TeamUIPlugin;
 import org.eclipse.team.internal.ui.sync.views.SynchronizeView;
 import org.eclipse.team.tests.ccvs.core.EclipseTest;
 import org.eclipse.team.tests.ccvs.core.subscriber.CVSMergeSubscriberTest;
@@ -39,7 +37,6 @@ public class AllTestsSynchronizeView extends EclipseTest {
 		
 		// sync info tests re-using the subscribers tests but checking state based on the 
 		// sync set data structures in the synchronize view.
-		TeamUIPlugin.getPlugin().getPreferenceStore().setValue(IPreferenceIds.TESTING_SYNCVIEW, true);
 		suite.addTest(CVSMergeSubscriberTest.suite());
 		suite.addTest(CVSWorkspaceSubscriberTest.suite());
 		CVSSyncSubscriberTest.setSyncSource(new SyncInfoFromSyncSet());
diff --git a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/SyncInfoFromSyncSet.java b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/SyncInfoFromSyncSet.java
index 20bea0680..09d97b3f2 100644
--- a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/SyncInfoFromSyncSet.java
+++ b/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/sync/SyncInfoFromSyncSet.java
@@ -14,6 +14,7 @@ import junit.framework.AssertionFailedError;
 
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.team.core.TeamException;
 import org.eclipse.team.core.subscribers.SyncInfo;
@@ -31,6 +32,23 @@ public class SyncInfoFromSyncSet extends SyncInfoSource {
 	public SyncInfoFromSyncSet() {		
 	}
 	
+	public void waitForEventNotification(SubscriberInput input) {
+		// process UI events first, give the main thread a chance
+		// to handle any syncExecs or asyncExecs posted as a result
+		// of the event processing thread.
+		while (Display.getCurrent().readAndDispatch()) {};
+		
+		// wait for the event handler to process changes.
+		Job job = input.getEventHandler().getEventHandlerJob();
+		while(job.getState() != Job.NONE) {
+			while (Display.getCurrent().readAndDispatch()) {};
+			try {
+				Thread.sleep(50);
+			} catch (InterruptedException e) {
+			}
+		}						
+	}
+	
 	public SyncInfo getSyncInfo(TeamSubscriber subscriber, IResource resource) throws TeamException {
 		SubscriberInput input = getInput(subscriber);
 		SyncSet set = input.getWorkingSetSyncSet();
@@ -51,19 +69,19 @@ public class SyncInfoFromSyncSet extends SyncInfoSource {
 		if (subscriber != input.getSubscriber()) {
 			// ensure that the CVS subscriber is active
 			syncView.activateSubscriber(subscriber);
-			while (Display.getCurrent().readAndDispatch()) {};			
 			input = syncView.getInput();
 		}
 		if (subscriber != input.getSubscriber()) {
 			throw new AssertionFailedError();
 		}
+		waitForEventNotification(input);
 		return input;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.tests.ccvs.core.subscriber.SyncInfoSource#assertProjectRemoved(org.eclipse.team.core.subscribers.TeamSubscriber, org.eclipse.core.resources.IProject)
 	 */
-	protected void assertProjectRemoved(TeamSubscriber subscriber, IProject project) throws TeamException {
+	protected void assertProjectRemoved(TeamSubscriber subscriber, IProject project) throws TeamException {		
 		super.assertProjectRemoved(subscriber, project);
 		SubscriberInput input = getInput(subscriber);
 		SyncSet set = input.getFilteredSyncSet();