tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/api/IAggregateWorkingSetTest.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2009 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ui.tests.api;

 import java.lang.reflect.Method;

 import org.eclipse.core.resources.IWorkspace;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.ui.IAggregateWorkingSet;
 import org.eclipse.ui.IMemento;
 import org.eclipse.ui.IWorkingSet;
 import org.eclipse.ui.IWorkingSetManager;
 import org.eclipse.ui.XMLMemento;
 import org.eclipse.ui.internal.AbstractWorkingSet;
 import org.eclipse.ui.internal.AbstractWorkingSetManager;
 import org.eclipse.ui.internal.AggregateWorkingSet;
 import org.eclipse.ui.internal.IWorkbenchConstants;
 import org.eclipse.ui.tests.harness.util.ArrayUtil;
 import org.eclipse.ui.tests.harness.util.UITestCase;

 public class IAggregateWorkingSetTest extends UITestCase {

 	final static String WORKING_SET_NAME = "testws";
 	final static String AGGREGATE_WORKING_SET_NAME_ = "testaggregatews";
 	final static String WSET_PAGE_ID="org.eclipse.ui.resourceWorkingSetPage";
 	IWorkspace fWorkspace;

 	IWorkingSet[] components;
 	IAggregateWorkingSet fWorkingSet;

 	public IAggregateWorkingSetTest(String testName) {
 		super(testName);
 	}

 	protected void doSetUp() throws Exception {
 		super.doSetUp();
 		IWorkingSetManager workingSetManager = fWorkbench
 		.getWorkingSetManager();

 		fWorkspace = ResourcesPlugin.getWorkspace();
 		components = new IWorkingSet[4];
 		for (int i = 0; i < 4; i++) {
 			components[i] = workingSetManager.createWorkingSet(WORKING_SET_NAME
 					+ i, new IAdaptable[] {});
 			workingSetManager.addWorkingSet(components[i]);
 		}
 		fWorkingSet = (IAggregateWorkingSet) workingSetManager
 		.createAggregateWorkingSet(AGGREGATE_WORKING_SET_NAME_,
 				AGGREGATE_WORKING_SET_NAME_, components);

 		workingSetManager.addWorkingSet(fWorkingSet);
 	}
 	protected void doTearDown() throws Exception {
 		IWorkingSetManager workingSetManager = fWorkbench.getWorkingSetManager();
 		workingSetManager.removeWorkingSet(fWorkingSet);
 		for (int i = 0; i < components.length; i++) {
 			workingSetManager.removeWorkingSet(components[i]);
 		}
 		super.doTearDown();
 	}

 	public void testSaveWSet() throws Throwable {
 		//<possible client code>
 		IWorkingSetManager workingSetManager = fWorkbench
 		.getWorkingSetManager();
 		IWorkingSet set=workingSetManager.getWorkingSet(AGGREGATE_WORKING_SET_NAME_);
 		if(set.isAggregateWorkingSet()){
 			IWorkingSet[] sets=((IAggregateWorkingSet)set).getComponents();
 			if(sets.length>=1){
 				sets[0]=null; //client fails to pay enough attention to specs or unknowingly does this
 			}
 		}
 		//</possible client code>
 		//error makes it look like it comes from workingsets api, with no clue about the actual culprit
 		IMemento memento=XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
 		set.saveState(memento);
 	}
 	public void testGetElemets() throws Throwable {
 		//<possible client code>
 		IWorkingSetManager workingSetManager = fWorkbench
 		.getWorkingSetManager();
 		IWorkingSet set=workingSetManager.getWorkingSet(AGGREGATE_WORKING_SET_NAME_);
 		if(set.isAggregateWorkingSet()){
 			IWorkingSet[] sets=((IAggregateWorkingSet)set).getComponents();
 			if(sets.length>1){
 				//code 2 fails to pay enough attention to specs or unknowingly does this
 				sets[0]=workingSetManager.createWorkingSet(WORKING_SET_NAME, new IAdaptable[] { fWorkspace.getRoot() });
 				//code 1 part  removes a workingset
 				workingSetManager.removeWorkingSet(sets[1]);
 			}
 		}
 		//</possible client code>

 		//unexpected
 		assertTrue(ArrayUtil.equals(
 				new IAdaptable[] {},
 				fWorkingSet.getElements()));
 	}

 	/**
 	 * Core of the problem: while Eclipse is running, name collisions among working sets
 	 * don't matter. However, on save and restart names will be used to identify working
 	 * sets, which could possibly lead to cycles in aggregate working sets.
 	 *
 	 * Bottom line: if there are multiple aggregate working sets with the same name, expect
 	 * trouble on restart.
 	 *
 	 * To create a cycle we have to be creative:
 	 * - create an aggregate1 with an ID = "testCycle"
 	 * - create an aggregate2 with an ID = "testCycle" containing aggregate1
 	 * - save it into IMemento
 	 *
 	 * Now the IMememnto creates a self reference:
 	 *
 	 * <workingSet name="testCycle" label="testCycle" aggregate="true">
 	 * 	<workingSet IMemento.internal.id="testCycle" />
 	 * </workingSet>
 	 *
 	 * All we have to do to emulate stack overflow is to create a working set based on this IMemento.
 	 *
 	 * @throws Throwable
 	 */
 	public void testWorkingSetCycle() throws Throwable {
 		IWorkingSetManager manager = fWorkbench.getWorkingSetManager();

 		// create an IMemento with a cycle in it
 		IAggregateWorkingSet aggregate = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[0]);

 		IAggregateWorkingSet aggregate2 = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[] {aggregate});

 		IMemento memento=XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
 		aggregate2.saveState(memento);

 		// load the IMemento
 		IAggregateWorkingSet aggregateReloaded = null;
 		try {
 			aggregateReloaded = (IAggregateWorkingSet) manager.createWorkingSet(memento);
 			manager.addWorkingSet(aggregateReloaded);
 			aggregateReloaded.getComponents();
 		} catch (StackOverflowError e) {
 			e.printStackTrace();
 			fail("Stack overflow for self-referenced aggregate working set", e);
 		} finally {
 			if (aggregateReloaded != null)
 				manager.removeWorkingSet(aggregateReloaded);
 		}
 	}

 	/**
 	 * Tests cleanup of the cycle from an aggregate working set.
 	 * @throws Throwable
 	 */
 	public void testCycleCleanup() throws Throwable {
 		IWorkingSetManager manager = fWorkbench.getWorkingSetManager();

 		// create an IMemento with a cycle in it: { good, good, cycle, good, good }
 		IAggregateWorkingSet aggregateSub0 = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle0","testCycle0", new IWorkingSet[0]);

 		IAggregateWorkingSet aggregateSub1 = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle1","testCycle1", new IWorkingSet[0]);

 		IAggregateWorkingSet aggregateSub2 = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[0]); // cycle

 		IAggregateWorkingSet aggregateSub3 = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle3","testCycle3", new IWorkingSet[0]);

 		IAggregateWorkingSet aggregateSub4 = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle4","testCycle4", new IWorkingSet[0]);


 		IAggregateWorkingSet aggregate = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[] {aggregateSub0,
 				aggregateSub1, aggregateSub2, aggregateSub3, aggregateSub4});

 		manager.addWorkingSet(aggregateSub0);
 		manager.addWorkingSet(aggregateSub1);
 		manager.addWorkingSet(aggregateSub3);
 		manager.addWorkingSet(aggregateSub4);

 		IMemento memento=XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
 		aggregate.saveState(memento);

 		// load the IMemento
 		IAggregateWorkingSet aggregateReloaded = null;
 		try {
 			aggregateReloaded = (IAggregateWorkingSet) manager.createWorkingSet(memento);
 			manager.addWorkingSet(aggregateReloaded);
 			IWorkingSet[] aggregates = aggregateReloaded.getComponents();
 			assertNotNull(aggregates);
 			assertEquals(4, aggregates.length);
 			for(int i = 0; i < aggregates.length; i++)
 				assertFalse("testCycle".equals(aggregates[i].getName()));
 		} catch (StackOverflowError e) {
 			e.printStackTrace();
 			fail("Stack overflow for self-referenced aggregate working set", e);
 		} finally {
 			if (aggregateReloaded != null)
 				manager.removeWorkingSet(aggregateReloaded);
 		}
 	}

 	/*
 	 * Test related to Bug 217955.The initial fix made changes that caused
 	 * save/restore to fail due to early restore and forward reference in
 	 * memento of aggregates
 	 */
 	public void testWorkingSetSaveRestoreAggregates() throws Throwable {
 		IWorkingSetManager manager = fWorkbench.getWorkingSetManager();
 		String nameA = "A";
 		String nameB = "B";
 		String nameC = "C";

 		IWorkingSet wSetA = manager
 				.createWorkingSet(nameA, new IAdaptable[] {});
 		manager.addWorkingSet(wSetA);

 		IAggregateWorkingSet wSetB = (IAggregateWorkingSet) manager
 		.createAggregateWorkingSet(nameB, nameB, new IWorkingSet[] {});
 		manager.addWorkingSet(wSetB);

 		IAggregateWorkingSet wSetC = (IAggregateWorkingSet) manager
 				.createAggregateWorkingSet(nameC, nameC, new IWorkingSet[0]);
 		manager.addWorkingSet(wSetC);

 		try {
 			assertEquals("Failed to add workingset" + nameA, wSetA, manager
 					.getWorkingSet(nameA));

 			assertEquals("Failed to add workingset" + nameC, wSetC, manager
 					.getWorkingSet(nameC));

 			assertEquals("Failed to add workingset" + nameB, wSetB, manager
 					.getWorkingSet(nameB));

 			invokeMethod(AggregateWorkingSet.class, "setComponents", wSetB,
 					new Object[] { new IWorkingSet[] {
 							wSetA, wSetC } },
 					new Class[] { new IWorkingSet[] {}.getClass() });

 			saveRestoreWorkingSetManager();

 			IAggregateWorkingSet restoredB = (IAggregateWorkingSet) manager
 					.getWorkingSet(nameB);
 			assertTrue("Unable to save/restore correctly", restoredB!=null);

 			IAggregateWorkingSet restoredC = (IAggregateWorkingSet) manager
 			.getWorkingSet(nameC);
 			assertTrue("Unable to save/restore correctly", restoredC!=null);

 			IWorkingSet[] componenets1=wSetB.getComponents();
 			IWorkingSet[] componenets2=((IAggregateWorkingSet) manager
 					.getWorkingSet(nameB)).getComponents();

 			if (componenets1.length != componenets2.length)
 				fail(nameB + " has lost data in the process of save/restore");
 	        else {
 	            for (int i = 0; i < componenets1.length; i++)
 	                if (!componenets1[i].equals(componenets2[i]))
 	                	fail(nameB + " has lost data in the process of save/restore");
 	        }

 		} finally {
 			// restore
 			IWorkingSet set = manager.getWorkingSet(nameA);
 			if (set != null) {
 				manager.removeWorkingSet(set);
 			}
 			set = manager.getWorkingSet(nameB);
 			if (set != null) {
 				manager.removeWorkingSet(set);
 			}
 			set = manager.getWorkingSet(nameC);
 			if (set != null) {
 				manager.removeWorkingSet(set);
 			}
 		}
 	}

 	private void saveRestoreWorkingSetManager() {
 		IMemento managerMemento = XMLMemento
 				.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET_MANAGER);
 		IWorkingSetManager manager = fWorkbench.getWorkingSetManager();
 		IWorkingSet[] sets = manager.getAllWorkingSets();
 		for (int i = 0; i < sets.length; i++) {
 			if(sets[i].getId()==null){
 				//set default id as set by factory
 				sets[i].setId(WSET_PAGE_ID);
 			}
 		}
 		invokeMethod(AbstractWorkingSetManager.class, "saveWorkingSetState",
 				manager, new Object[] { managerMemento },
 				new Class[] { IMemento.class });
 		invokeMethod(AbstractWorkingSetManager.class, "saveMruList", manager,
 				new Object[] { managerMemento }, new Class[] { IMemento.class });
 		for (int i = 0; i < sets.length; i++) {
 			((AbstractWorkingSet) sets[i]).disconnect();
 		}
 		for (int i = 0; i < sets.length; i++) {
 			manager.removeWorkingSet(sets[i]);
 		}
 		//manager.dispose(); //not needed, also cause problems
 		invokeMethod(AbstractWorkingSetManager.class, "restoreWorkingSetState",
 				manager, new Object[] { managerMemento },
 				new Class[] { IMemento.class });
 		invokeMethod(AbstractWorkingSetManager.class, "restoreMruList",
 				manager, new Object[] { managerMemento },
 				new Class[] { IMemento.class });
 	}

 	private Object invokeMethod(Class clazz, String methodName,
 			Object instance, Object[] args, Class[] argsClasses) {
 		try {
 			Method method = clazz.getDeclaredMethod(methodName, argsClasses);
 			method.setAccessible(true);
 			return method.invoke(instance, args);
 		} catch (Exception e) {
 			fail("Failure in invoking " + clazz.getName() + methodName, e);
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2009 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.ui.tests.api;

	import java.lang.reflect.Method;

	import org.eclipse.core.resources.IWorkspace;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.ui.IAggregateWorkingSet;
	import org.eclipse.ui.IMemento;
	import org.eclipse.ui.IWorkingSet;
	import org.eclipse.ui.IWorkingSetManager;
	import org.eclipse.ui.XMLMemento;
	import org.eclipse.ui.internal.AbstractWorkingSet;
	import org.eclipse.ui.internal.AbstractWorkingSetManager;
	import org.eclipse.ui.internal.AggregateWorkingSet;
	import org.eclipse.ui.internal.IWorkbenchConstants;
	import org.eclipse.ui.tests.harness.util.ArrayUtil;
	import org.eclipse.ui.tests.harness.util.UITestCase;

	public class IAggregateWorkingSetTest extends UITestCase {

	final static String WORKING_SET_NAME = "testws";
	final static String AGGREGATE_WORKING_SET_NAME_ = "testaggregatews";
	final static String WSET_PAGE_ID="org.eclipse.ui.resourceWorkingSetPage";
	IWorkspace fWorkspace;

	IWorkingSet[] components;
	IAggregateWorkingSet fWorkingSet;

	public IAggregateWorkingSetTest(String testName) {
	super(testName);
	}

	protected void doSetUp() throws Exception {
	super.doSetUp();
	IWorkingSetManager workingSetManager = fWorkbench
	.getWorkingSetManager();

	fWorkspace = ResourcesPlugin.getWorkspace();
	components = new IWorkingSet[4];
	for (int i = 0; i < 4; i++) {
	components[i] = workingSetManager.createWorkingSet(WORKING_SET_NAME
	+ i, new IAdaptable[] {});
	workingSetManager.addWorkingSet(components[i]);
	}
	fWorkingSet = (IAggregateWorkingSet) workingSetManager
	.createAggregateWorkingSet(AGGREGATE_WORKING_SET_NAME_,
	AGGREGATE_WORKING_SET_NAME_, components);

	workingSetManager.addWorkingSet(fWorkingSet);
	}
	protected void doTearDown() throws Exception {
	IWorkingSetManager workingSetManager = fWorkbench.getWorkingSetManager();
	workingSetManager.removeWorkingSet(fWorkingSet);
	for (int i = 0; i < components.length; i++) {
	workingSetManager.removeWorkingSet(components[i]);
	}
	super.doTearDown();
	}

	public void testSaveWSet() throws Throwable {
	//<possible client code>
	IWorkingSetManager workingSetManager = fWorkbench
	.getWorkingSetManager();
	IWorkingSet set=workingSetManager.getWorkingSet(AGGREGATE_WORKING_SET_NAME_);
	if(set.isAggregateWorkingSet()){
	IWorkingSet[] sets=((IAggregateWorkingSet)set).getComponents();
	if(sets.length>=1){
	sets[0]=null; //client fails to pay enough attention to specs or unknowingly does this
	}
	}
	//</possible client code>
	//error makes it look like it comes from workingsets api, with no clue about the actual culprit
	IMemento memento=XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
	set.saveState(memento);
	}
	public void testGetElemets() throws Throwable {
	//<possible client code>
	IWorkingSetManager workingSetManager = fWorkbench
	.getWorkingSetManager();
	IWorkingSet set=workingSetManager.getWorkingSet(AGGREGATE_WORKING_SET_NAME_);
	if(set.isAggregateWorkingSet()){
	IWorkingSet[] sets=((IAggregateWorkingSet)set).getComponents();
	if(sets.length>1){
	//code 2 fails to pay enough attention to specs or unknowingly does this
	sets[0]=workingSetManager.createWorkingSet(WORKING_SET_NAME, new IAdaptable[] { fWorkspace.getRoot() });
	//code 1 part removes a workingset
	workingSetManager.removeWorkingSet(sets[1]);
	}
	}
	//</possible client code>

	//unexpected
	assertTrue(ArrayUtil.equals(
	new IAdaptable[] {},
	fWorkingSet.getElements()));
	}

	/**
	* Core of the problem: while Eclipse is running, name collisions among working sets
	* don't matter. However, on save and restart names will be used to identify working
	* sets, which could possibly lead to cycles in aggregate working sets.
	*
	* Bottom line: if there are multiple aggregate working sets with the same name, expect
	* trouble on restart.
	*
	* To create a cycle we have to be creative:
	* - create an aggregate1 with an ID = "testCycle"
	* - create an aggregate2 with an ID = "testCycle" containing aggregate1
	* - save it into IMemento
	*
	* Now the IMememnto creates a self reference:
	*
	* <workingSet name="testCycle" label="testCycle" aggregate="true">
	* <workingSet IMemento.internal.id="testCycle" />
	* </workingSet>
	*
	* All we have to do to emulate stack overflow is to create a working set based on this IMemento.
	*
	* @throws Throwable
	*/
	public void testWorkingSetCycle() throws Throwable {
	IWorkingSetManager manager = fWorkbench.getWorkingSetManager();

	// create an IMemento with a cycle in it
	IAggregateWorkingSet aggregate = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[0]);

	IAggregateWorkingSet aggregate2 = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[] {aggregate});

	IMemento memento=XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
	aggregate2.saveState(memento);

	// load the IMemento
	IAggregateWorkingSet aggregateReloaded = null;
	try {
	aggregateReloaded = (IAggregateWorkingSet) manager.createWorkingSet(memento);
	manager.addWorkingSet(aggregateReloaded);
	aggregateReloaded.getComponents();
	} catch (StackOverflowError e) {
	e.printStackTrace();
	fail("Stack overflow for self-referenced aggregate working set", e);
	} finally {
	if (aggregateReloaded != null)
	manager.removeWorkingSet(aggregateReloaded);
	}
	}

	/**
	* Tests cleanup of the cycle from an aggregate working set.
	* @throws Throwable
	*/
	public void testCycleCleanup() throws Throwable {
	IWorkingSetManager manager = fWorkbench.getWorkingSetManager();

	// create an IMemento with a cycle in it: { good, good, cycle, good, good }
	IAggregateWorkingSet aggregateSub0 = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle0","testCycle0", new IWorkingSet[0]);

	IAggregateWorkingSet aggregateSub1 = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle1","testCycle1", new IWorkingSet[0]);

	IAggregateWorkingSet aggregateSub2 = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[0]); // cycle

	IAggregateWorkingSet aggregateSub3 = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle3","testCycle3", new IWorkingSet[0]);

	IAggregateWorkingSet aggregateSub4 = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle4","testCycle4", new IWorkingSet[0]);


	IAggregateWorkingSet aggregate = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet("testCycle","testCycle", new IWorkingSet[] {aggregateSub0,
	aggregateSub1, aggregateSub2, aggregateSub3, aggregateSub4});

	manager.addWorkingSet(aggregateSub0);
	manager.addWorkingSet(aggregateSub1);
	manager.addWorkingSet(aggregateSub3);
	manager.addWorkingSet(aggregateSub4);

	IMemento memento=XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
	aggregate.saveState(memento);

	// load the IMemento
	IAggregateWorkingSet aggregateReloaded = null;
	try {
	aggregateReloaded = (IAggregateWorkingSet) manager.createWorkingSet(memento);
	manager.addWorkingSet(aggregateReloaded);
	IWorkingSet[] aggregates = aggregateReloaded.getComponents();
	assertNotNull(aggregates);
	assertEquals(4, aggregates.length);
	for(int i = 0; i < aggregates.length; i++)
	assertFalse("testCycle".equals(aggregates[i].getName()));
	} catch (StackOverflowError e) {
	e.printStackTrace();
	fail("Stack overflow for self-referenced aggregate working set", e);
	} finally {
	if (aggregateReloaded != null)
	manager.removeWorkingSet(aggregateReloaded);
	}
	}

	/*
	* Test related to Bug 217955.The initial fix made changes that caused
	* save/restore to fail due to early restore and forward reference in
	* memento of aggregates
	*/
	public void testWorkingSetSaveRestoreAggregates() throws Throwable {
	IWorkingSetManager manager = fWorkbench.getWorkingSetManager();
	String nameA = "A";
	String nameB = "B";
	String nameC = "C";

	IWorkingSet wSetA = manager
	.createWorkingSet(nameA, new IAdaptable[] {});
	manager.addWorkingSet(wSetA);

	IAggregateWorkingSet wSetB = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet(nameB, nameB, new IWorkingSet[] {});
	manager.addWorkingSet(wSetB);

	IAggregateWorkingSet wSetC = (IAggregateWorkingSet) manager
	.createAggregateWorkingSet(nameC, nameC, new IWorkingSet[0]);
	manager.addWorkingSet(wSetC);

	try {
	assertEquals("Failed to add workingset" + nameA, wSetA, manager
	.getWorkingSet(nameA));

	assertEquals("Failed to add workingset" + nameC, wSetC, manager
	.getWorkingSet(nameC));

	assertEquals("Failed to add workingset" + nameB, wSetB, manager
	.getWorkingSet(nameB));

	invokeMethod(AggregateWorkingSet.class, "setComponents", wSetB,
	new Object[] { new IWorkingSet[] {
	wSetA, wSetC } },
	new Class[] { new IWorkingSet[] {}.getClass() });

	saveRestoreWorkingSetManager();

	IAggregateWorkingSet restoredB = (IAggregateWorkingSet) manager
	.getWorkingSet(nameB);
	assertTrue("Unable to save/restore correctly", restoredB!=null);

	IAggregateWorkingSet restoredC = (IAggregateWorkingSet) manager
	.getWorkingSet(nameC);
	assertTrue("Unable to save/restore correctly", restoredC!=null);

	IWorkingSet[] componenets1=wSetB.getComponents();
	IWorkingSet[] componenets2=((IAggregateWorkingSet) manager
	.getWorkingSet(nameB)).getComponents();

	if (componenets1.length != componenets2.length)
	fail(nameB + " has lost data in the process of save/restore");
	else {
	for (int i = 0; i < componenets1.length; i++)
	if (!componenets1[i].equals(componenets2[i]))
	fail(nameB + " has lost data in the process of save/restore");
	}

	} finally {
	// restore
	IWorkingSet set = manager.getWorkingSet(nameA);
	if (set != null) {
	manager.removeWorkingSet(set);
	}
	set = manager.getWorkingSet(nameB);
	if (set != null) {
	manager.removeWorkingSet(set);
	}
	set = manager.getWorkingSet(nameC);
	if (set != null) {
	manager.removeWorkingSet(set);
	}
	}
	}

	private void saveRestoreWorkingSetManager() {
	IMemento managerMemento = XMLMemento
	.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET_MANAGER);
	IWorkingSetManager manager = fWorkbench.getWorkingSetManager();
	IWorkingSet[] sets = manager.getAllWorkingSets();
	for (int i = 0; i < sets.length; i++) {
	if(sets[i].getId()==null){
	//set default id as set by factory
	sets[i].setId(WSET_PAGE_ID);
	}
	}
	invokeMethod(AbstractWorkingSetManager.class, "saveWorkingSetState",
	manager, new Object[] { managerMemento },
	new Class[] { IMemento.class });
	invokeMethod(AbstractWorkingSetManager.class, "saveMruList", manager,
	new Object[] { managerMemento }, new Class[] { IMemento.class });
	for (int i = 0; i < sets.length; i++) {
	((AbstractWorkingSet) sets[i]).disconnect();
	}
	for (int i = 0; i < sets.length; i++) {
	manager.removeWorkingSet(sets[i]);
	}
	//manager.dispose(); //not needed, also cause problems
	invokeMethod(AbstractWorkingSetManager.class, "restoreWorkingSetState",
	manager, new Object[] { managerMemento },
	new Class[] { IMemento.class });
	invokeMethod(AbstractWorkingSetManager.class, "restoreMruList",
	manager, new Object[] { managerMemento },
	new Class[] { IMemento.class });
	}

	private Object invokeMethod(Class clazz, String methodName,
	Object instance, Object[] args, Class[] argsClasses) {
	try {
	Method method = clazz.getDeclaredMethod(methodName, argsClasses);
	method.setAccessible(true);
	return method.invoke(instance, args);
	} catch (Exception e) {
	fail("Failure in invoking " + clazz.getName() + methodName, e);
	}
	return null;
	}
	}