org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/breakpoints/ImportBreakpointsTest.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2012 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.jdt.debug.tests.breakpoints;

 import java.io.File;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;

 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.internal.ui.breakpoints.provisional.IBreakpointOrganizer;
 import org.eclipse.debug.internal.ui.views.breakpoints.BreakpointOrganizerManager;
 import org.eclipse.debug.internal.ui.views.breakpoints.WorkingSetCategory;
 import org.eclipse.debug.ui.actions.ExportBreakpointsOperation;
 import org.eclipse.debug.ui.actions.ImportBreakpointsOperation;
 import org.eclipse.jdt.debug.core.IJavaBreakpoint;
 import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;
 import org.eclipse.ui.IWorkingSet;
 import org.eclipse.ui.IWorkingSetManager;

 /**
  * Tests the import operations of the breakpoint import export feature
  *
  * @since 3.2
  */
 public class ImportBreakpointsTest extends AbstractBreakpointWorkingSetTest {

 	/**
 	 * Default constructor
 	 * @param name the name for the test
 	 */
 	public ImportBreakpointsTest(String name) {super(name);}

 	/**
 	 * Tests import operation from a file.
 	 * @throws Exception catch all passed to framework
 	 */
 	public void testBreakpointImportFile() throws Exception {
 		try {
 			ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
 			String typeName = "DropTests";
 			breakpoints.add(createClassPrepareBreakpoint(typeName));
 			breakpoints.add(createLineBreakpoint(32, typeName));
 			breakpoints.add(createLineBreakpoint(28, typeName));
 			breakpoints.add(createLineBreakpoint(24, typeName));
 			breakpoints.add(createExceptionBreakpoint("Exception", true, false));
 			breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
 			assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
 			Path path = new Path("exbkptA.bkpt");
 			assertNotNull("Invalid path", path);
 			ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]), path.toOSString());
 			op.run(new NullProgressMonitor());
 			removeAllBreakpoints();
 			File file = path.toFile();
 			assertNotNull(file);
 			assertEquals(true, file.exists());
 			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
 			op2.run(new NullProgressMonitor());
 			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
 			IBreakpoint[] importedBreakpoints = op2.getImportedBreakpoints();
 			assertEquals("imported list should contain same breakpoints", 6, importedBreakpoints.length);
 			for (int i = 0; i < importedBreakpoints.length; i++) {
 				IBreakpoint breakpoint = importedBreakpoints[i];
 				assertEquals("Missing imported breakpoint", breakpoint, getBreakpointManager().getBreakpoint(breakpoint.getMarker()));
 			}
 			file.delete();
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * Tests import operation from a string buffer.
 	 *
 	 * @throws Exception catch all passed to framework
 	 */
 	public void testBreakpointImportBuffer() throws Exception {
 		try {
 			ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
 			String typeName = "DropTests";
 			breakpoints.add(createClassPrepareBreakpoint(typeName));
 			breakpoints.add(createLineBreakpoint(32, typeName));
 			breakpoints.add(createLineBreakpoint(28, typeName));
 			breakpoints.add(createLineBreakpoint(24, typeName));
 			breakpoints.add(createExceptionBreakpoint("Exception", true, false));
 			breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
 			assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
 			ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]));
 			op.run(new NullProgressMonitor());
 			StringBuffer buffer = op.getBuffer();
 			assertNotNull("Missing buffer", buffer);
 			removeAllBreakpoints();
 			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(buffer, true, true);
 			op2.run(new NullProgressMonitor());
 			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * tests and overwrote without remove all
 	 * @throws Exception catch all to pass back to framework
 	 */
 	public void testBreakpointImportOverwrite() throws Exception {
 		try {
 			ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
 			String typeName = "DropTests";
 			breakpoints.add(createClassPrepareBreakpoint(typeName));
 			breakpoints.add(createLineBreakpoint(32, typeName));
 			breakpoints.add(createLineBreakpoint(28, typeName));
 			breakpoints.add(createLineBreakpoint(24, typeName));
 			breakpoints.add(createExceptionBreakpoint("Exception", true, false));
 			breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
 			assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
 			Path path = new Path("exbkptB.bkpt");
 			assertNotNull("Invalid path", path);
 			ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]), path.toOSString());
 			op.run(new NullProgressMonitor());
 			File file = path.toFile();
 			assertNotNull(file);
 			assertEquals(true, file.exists());
 			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
 			op2.run(new NullProgressMonitor());
 			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
 			file.delete();
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * Tests a bad filename passed to the import operation
 	 *
 	 * @throws Exception catch all to pass back to framework
 	 */
 	public void testBreakpointImportBadFilename() throws Exception {
 		try {
 			ImportBreakpointsOperation op = new ImportBreakpointsOperation("Badpath", true, true);
 			try {
 				op.run(new NullProgressMonitor());
 			} catch (InvocationTargetException e) {
 				assertEquals("should be no breakpoints", 0, getBreakpointManager().getBreakpoints().length);
 				return;
 			}
 			assertTrue("Import should have failed with exception", false);
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * tests importing breakpoints with working sets
 	 *
 	 * @throws Exception catch all to be passed back to the framework
 	 */
 	public void testBreakpointImportWithWorkingsets() throws Exception {
 		try {
 		//create the working set and add breakpoints to it
 			IBreakpointOrganizer bporg = BreakpointOrganizerManager.getDefault().getOrganizer("org.eclipse.debug.ui.breakpointWorkingSetOrganizer");
 			IWorkingSetManager wsmanager = getWorkingSetManager();
 			String typeName = "DropTests";
 			String setName = "ws_name";
 			IWorkingSet set = createSet(setName);
 			assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setName));
 			WorkingSetCategory category = new WorkingSetCategory(set);

 			bporg.addBreakpoint(createClassPrepareBreakpoint(typeName), category);
 			bporg.addBreakpoint(createLineBreakpoint(32, typeName), category);
 			bporg.addBreakpoint(createLineBreakpoint(28, typeName), category);
 			bporg.addBreakpoint(createLineBreakpoint(24, typeName), category);
 			bporg.addBreakpoint(createExceptionBreakpoint("Exception", true, false), category);
 			bporg.addBreakpoint(createMethodBreakpoint(typeName, "method4", "()V", true, false), category);
 			assertEquals("workingset does not have 6 elements", 6, set.getElements().length);
 			assertEquals("manager does not have 6 breakpoints", getBreakpointManager().getBreakpoints().length, 6);
 			Path path = new Path("exbkptC.bkpt");
 			assertNotNull("Invalid path", path);
 			ExportBreakpointsOperation op = new ExportBreakpointsOperation(getBreakpointManager().getBreakpoints(), path.toOSString());
 			op.run(new NullProgressMonitor());

 			//remove bps and working set and do the import
 			removeAllBreakpoints();
 			set.setElements(new IAdaptable[] {});
 			wsmanager.removeWorkingSet(set);
 			set = wsmanager.getWorkingSet(setName);
 			assertNull("workingset was not removed", set);
 			set = null;
 			File file = path.toFile();
 			assertNotNull(file);
 			assertEquals(true, file.exists());
 			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
 			op2.run(new NullProgressMonitor());
 			set = wsmanager.getWorkingSet(setName);
 			assertNotNull("Import did not create working set", set);
 			assertEquals("workingset does not contain 6 breakpoints", 6, set.getElements().length);
 			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
 			file.delete();
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * Tests importing breakpoints to resources that do not exist
 	 * @throws Exception catch all passed to framework
 	 */
 	public void testBreakpointImportMissingResources() throws Exception {
 		try {
 			File file = JavaTestPlugin.getDefault().getFileInPlugin(new Path("testresources/brkpt_missing.bkpt"));
 			assertNotNull(file);
 			assertEquals(true, file.exists());
 			ImportBreakpointsOperation op = new ImportBreakpointsOperation(file.getCanonicalPath(), true, true);
 			op.run(new NullProgressMonitor());
 			assertEquals("should be no breakpoints imported", 0, getBreakpointManager().getBreakpoints().length);
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * tests importing breakpoints with working sets where the breakpoints are restored to
 	 * another working set and removed from the current one
 	 *
 	 * @throws Exception catch all to be passed back to the framework
 	 */
 	public void testImportWithWorkingsets() throws Exception {
 		try {
 		//create the working set and add breakpoints to it
 			IBreakpointOrganizer bporg = BreakpointOrganizerManager.getDefault().getOrganizer("org.eclipse.debug.ui.breakpointWorkingSetOrganizer");
 			IWorkingSetManager wsmanager = getWorkingSetManager();
 			String typeName = "DropTests";
 			String setname1 = "ws1";
 			String setname2 = "ws2";
 			IWorkingSet set = createSet(setname1);
 			assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setname1));
 			WorkingSetCategory category = new WorkingSetCategory(set);

 			bporg.addBreakpoint(createClassPrepareBreakpoint(typeName), category);
 			bporg.addBreakpoint(createLineBreakpoint(32, typeName), category);
 			bporg.addBreakpoint(createLineBreakpoint(28, typeName), category);
 			bporg.addBreakpoint(createLineBreakpoint(24, typeName), category);
 			bporg.addBreakpoint(createExceptionBreakpoint("Exception", true, false), category);
 			bporg.addBreakpoint(createMethodBreakpoint(typeName, "method4", "()V", true, false), category);
 			assertEquals("workingset does not have 6 elements", 6, set.getElements().length);
 			assertEquals("manager does not have 6 breakpoints", getBreakpointManager().getBreakpoints().length, 6);
 			Path path = new Path("exbkptC.bkpt");
 			assertNotNull("Invalid path", path);
 			ExportBreakpointsOperation op = new ExportBreakpointsOperation(getBreakpointManager().getBreakpoints(), path.toOSString());
 			op.run(new NullProgressMonitor());

 			//copy items to the alternate working set
 			IWorkingSet set2 = createSet(setname2);
 			set2.setElements(set.getElements());
 			assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setname2));

 			//remove bps and working set and do the import
 			removeAllBreakpoints();
 			set.setElements(new IAdaptable[] {});
 			wsmanager.removeWorkingSet(set);
 			set = wsmanager.getWorkingSet(setname1);
 			assertNull("workingset was not removed", set);
 			set = null;
 			File file = path.toFile();
 			assertNotNull(file);
 			assertEquals(true, file.exists());
 			ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
 			op2.run(new NullProgressMonitor());
 			set = wsmanager.getWorkingSet(setname1);
 			assertNotNull("Import did not create working set", set);
 			assertEquals("workingset does not contain 6 breakpoints", 6, set.getElements().length);
 			assertEquals("alternate working set should contain no breakpoints", 0, set2.getElements().length);
 			assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
 			file.delete();
 		}
 		finally {
 			removeAllBreakpoints();
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2012 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.jdt.debug.tests.breakpoints;

	import java.io.File;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;

	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.debug.core.model.IBreakpoint;
	import org.eclipse.debug.internal.ui.breakpoints.provisional.IBreakpointOrganizer;
	import org.eclipse.debug.internal.ui.views.breakpoints.BreakpointOrganizerManager;
	import org.eclipse.debug.internal.ui.views.breakpoints.WorkingSetCategory;
	import org.eclipse.debug.ui.actions.ExportBreakpointsOperation;
	import org.eclipse.debug.ui.actions.ImportBreakpointsOperation;
	import org.eclipse.jdt.debug.core.IJavaBreakpoint;
	import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;
	import org.eclipse.ui.IWorkingSet;
	import org.eclipse.ui.IWorkingSetManager;

	/**
	* Tests the import operations of the breakpoint import export feature
	*
	* @since 3.2
	*/
	public class ImportBreakpointsTest extends AbstractBreakpointWorkingSetTest {

	/**
	* Default constructor
	* @param name the name for the test
	*/
	public ImportBreakpointsTest(String name) {super(name);}

	/**
	* Tests import operation from a file.
	* @throws Exception catch all passed to framework
	*/
	public void testBreakpointImportFile() throws Exception {
	try {
	ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
	String typeName = "DropTests";
	breakpoints.add(createClassPrepareBreakpoint(typeName));
	breakpoints.add(createLineBreakpoint(32, typeName));
	breakpoints.add(createLineBreakpoint(28, typeName));
	breakpoints.add(createLineBreakpoint(24, typeName));
	breakpoints.add(createExceptionBreakpoint("Exception", true, false));
	breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
	assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
	Path path = new Path("exbkptA.bkpt");
	assertNotNull("Invalid path", path);
	ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]), path.toOSString());
	op.run(new NullProgressMonitor());
	removeAllBreakpoints();
	File file = path.toFile();
	assertNotNull(file);
	assertEquals(true, file.exists());
	ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
	op2.run(new NullProgressMonitor());
	assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
	IBreakpoint[] importedBreakpoints = op2.getImportedBreakpoints();
	assertEquals("imported list should contain same breakpoints", 6, importedBreakpoints.length);
	for (int i = 0; i < importedBreakpoints.length; i++) {
	IBreakpoint breakpoint = importedBreakpoints[i];
	assertEquals("Missing imported breakpoint", breakpoint, getBreakpointManager().getBreakpoint(breakpoint.getMarker()));
	}
	file.delete();
	}
	finally {
	removeAllBreakpoints();
	}
	}

	/**
	* Tests import operation from a string buffer.
	*
	* @throws Exception catch all passed to framework
	*/
	public void testBreakpointImportBuffer() throws Exception {
	try {
	ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
	String typeName = "DropTests";
	breakpoints.add(createClassPrepareBreakpoint(typeName));
	breakpoints.add(createLineBreakpoint(32, typeName));
	breakpoints.add(createLineBreakpoint(28, typeName));
	breakpoints.add(createLineBreakpoint(24, typeName));
	breakpoints.add(createExceptionBreakpoint("Exception", true, false));
	breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
	assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
	ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]));
	op.run(new NullProgressMonitor());
	StringBuffer buffer = op.getBuffer();
	assertNotNull("Missing buffer", buffer);
	removeAllBreakpoints();
	ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(buffer, true, true);
	op2.run(new NullProgressMonitor());
	assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
	}
	finally {
	removeAllBreakpoints();
	}
	}

	/**
	* tests and overwrote without remove all
	* @throws Exception catch all to pass back to framework
	*/
	public void testBreakpointImportOverwrite() throws Exception {
	try {
	ArrayList<IJavaBreakpoint> breakpoints = new ArrayList<IJavaBreakpoint>();
	String typeName = "DropTests";
	breakpoints.add(createClassPrepareBreakpoint(typeName));
	breakpoints.add(createLineBreakpoint(32, typeName));
	breakpoints.add(createLineBreakpoint(28, typeName));
	breakpoints.add(createLineBreakpoint(24, typeName));
	breakpoints.add(createExceptionBreakpoint("Exception", true, false));
	breakpoints.add(createMethodBreakpoint(typeName, "method4", "()V", true, false));
	assertEquals("manager does not contain 6 breakpoints for exporting", getBreakpointManager().getBreakpoints().length, 6);
	Path path = new Path("exbkptB.bkpt");
	assertNotNull("Invalid path", path);
	ExportBreakpointsOperation op = new ExportBreakpointsOperation(breakpoints.toArray(new IBreakpoint[breakpoints.size()]), path.toOSString());
	op.run(new NullProgressMonitor());
	File file = path.toFile();
	assertNotNull(file);
	assertEquals(true, file.exists());
	ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
	op2.run(new NullProgressMonitor());
	assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
	file.delete();
	}
	finally {
	removeAllBreakpoints();
	}
	}

	/**
	* Tests a bad filename passed to the import operation
	*
	* @throws Exception catch all to pass back to framework
	*/
	public void testBreakpointImportBadFilename() throws Exception {
	try {
	ImportBreakpointsOperation op = new ImportBreakpointsOperation("Badpath", true, true);
	try {
	op.run(new NullProgressMonitor());
	} catch (InvocationTargetException e) {
	assertEquals("should be no breakpoints", 0, getBreakpointManager().getBreakpoints().length);
	return;
	}
	assertTrue("Import should have failed with exception", false);
	}
	finally {
	removeAllBreakpoints();
	}
	}

	/**
	* tests importing breakpoints with working sets
	*
	* @throws Exception catch all to be passed back to the framework
	*/
	public void testBreakpointImportWithWorkingsets() throws Exception {
	try {
	//create the working set and add breakpoints to it
	IBreakpointOrganizer bporg = BreakpointOrganizerManager.getDefault().getOrganizer("org.eclipse.debug.ui.breakpointWorkingSetOrganizer");
	IWorkingSetManager wsmanager = getWorkingSetManager();
	String typeName = "DropTests";
	String setName = "ws_name";
	IWorkingSet set = createSet(setName);
	assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setName));
	WorkingSetCategory category = new WorkingSetCategory(set);

	bporg.addBreakpoint(createClassPrepareBreakpoint(typeName), category);
	bporg.addBreakpoint(createLineBreakpoint(32, typeName), category);
	bporg.addBreakpoint(createLineBreakpoint(28, typeName), category);
	bporg.addBreakpoint(createLineBreakpoint(24, typeName), category);
	bporg.addBreakpoint(createExceptionBreakpoint("Exception", true, false), category);
	bporg.addBreakpoint(createMethodBreakpoint(typeName, "method4", "()V", true, false), category);
	assertEquals("workingset does not have 6 elements", 6, set.getElements().length);
	assertEquals("manager does not have 6 breakpoints", getBreakpointManager().getBreakpoints().length, 6);
	Path path = new Path("exbkptC.bkpt");
	assertNotNull("Invalid path", path);
	ExportBreakpointsOperation op = new ExportBreakpointsOperation(getBreakpointManager().getBreakpoints(), path.toOSString());
	op.run(new NullProgressMonitor());

	//remove bps and working set and do the import
	removeAllBreakpoints();
	set.setElements(new IAdaptable[] {});
	wsmanager.removeWorkingSet(set);
	set = wsmanager.getWorkingSet(setName);
	assertNull("workingset was not removed", set);
	set = null;
	File file = path.toFile();
	assertNotNull(file);
	assertEquals(true, file.exists());
	ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
	op2.run(new NullProgressMonitor());
	set = wsmanager.getWorkingSet(setName);
	assertNotNull("Import did not create working set", set);
	assertEquals("workingset does not contain 6 breakpoints", 6, set.getElements().length);
	assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
	file.delete();
	}
	finally {
	removeAllBreakpoints();
	}
	}

	/**
	* Tests importing breakpoints to resources that do not exist
	* @throws Exception catch all passed to framework
	*/
	public void testBreakpointImportMissingResources() throws Exception {
	try {
	File file = JavaTestPlugin.getDefault().getFileInPlugin(new Path("testresources/brkpt_missing.bkpt"));
	assertNotNull(file);
	assertEquals(true, file.exists());
	ImportBreakpointsOperation op = new ImportBreakpointsOperation(file.getCanonicalPath(), true, true);
	op.run(new NullProgressMonitor());
	assertEquals("should be no breakpoints imported", 0, getBreakpointManager().getBreakpoints().length);
	}
	finally {
	removeAllBreakpoints();
	}
	}

	/**
	* tests importing breakpoints with working sets where the breakpoints are restored to
	* another working set and removed from the current one
	*
	* @throws Exception catch all to be passed back to the framework
	*/
	public void testImportWithWorkingsets() throws Exception {
	try {
	//create the working set and add breakpoints to it
	IBreakpointOrganizer bporg = BreakpointOrganizerManager.getDefault().getOrganizer("org.eclipse.debug.ui.breakpointWorkingSetOrganizer");
	IWorkingSetManager wsmanager = getWorkingSetManager();
	String typeName = "DropTests";
	String setname1 = "ws1";
	String setname2 = "ws2";
	IWorkingSet set = createSet(setname1);
	assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setname1));
	WorkingSetCategory category = new WorkingSetCategory(set);

	bporg.addBreakpoint(createClassPrepareBreakpoint(typeName), category);
	bporg.addBreakpoint(createLineBreakpoint(32, typeName), category);
	bporg.addBreakpoint(createLineBreakpoint(28, typeName), category);
	bporg.addBreakpoint(createLineBreakpoint(24, typeName), category);
	bporg.addBreakpoint(createExceptionBreakpoint("Exception", true, false), category);
	bporg.addBreakpoint(createMethodBreakpoint(typeName, "method4", "()V", true, false), category);
	assertEquals("workingset does not have 6 elements", 6, set.getElements().length);
	assertEquals("manager does not have 6 breakpoints", getBreakpointManager().getBreakpoints().length, 6);
	Path path = new Path("exbkptC.bkpt");
	assertNotNull("Invalid path", path);
	ExportBreakpointsOperation op = new ExportBreakpointsOperation(getBreakpointManager().getBreakpoints(), path.toOSString());
	op.run(new NullProgressMonitor());

	//copy items to the alternate working set
	IWorkingSet set2 = createSet(setname2);
	set2.setElements(set.getElements());
	assertNotNull("workingset does not exist", wsmanager.getWorkingSet(setname2));

	//remove bps and working set and do the import
	removeAllBreakpoints();
	set.setElements(new IAdaptable[] {});
	wsmanager.removeWorkingSet(set);
	set = wsmanager.getWorkingSet(setname1);
	assertNull("workingset was not removed", set);
	set = null;
	File file = path.toFile();
	assertNotNull(file);
	assertEquals(true, file.exists());
	ImportBreakpointsOperation op2 = new ImportBreakpointsOperation(path.toOSString(), true, true);
	op2.run(new NullProgressMonitor());
	set = wsmanager.getWorkingSet(setname1);
	assertNotNull("Import did not create working set", set);
	assertEquals("workingset does not contain 6 breakpoints", 6, set.getElements().length);
	assertEquals("alternate working set should contain no breakpoints", 0, set2.getElements().length);
	assertEquals("manager does not contain 6 breakpoints", 6, getBreakpointManager().getBreakpoints().length);
	file.delete();
	}
	finally {
	removeAllBreakpoints();
	}
	}
	}