| /******************************************************************************* |
| * 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(); |
| } |
| } |
| } |