Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'debug/org.eclipse.cdt.debug.ui.tests/core/org')
-rw-r--r--debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java1236
-rw-r--r--debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/DebugTests.java6
-rw-r--r--debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/LocationTests.java6
3 files changed, 626 insertions, 622 deletions
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java
index f6256621f86..f74a9c2ff16 100644
--- a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java
+++ b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java
@@ -1,11 +1,9 @@
package org.eclipse.cdt.debug.core.tests;
/*
- * (c) Copyright QNX Software Systems Ltd. 2002.
- * All Rights Reserved.
+ * (c) Copyright QNX Software Systems Ltd. 2002. All Rights Reserved.
*/
-
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
@@ -37,661 +35,667 @@ import org.eclipse.core.runtime.Path;
/**
* @author Peter Graves
- *
+ *
* This file contains a set of generic tests for the CDI break point interfaces.
* It will currenly use the mi implementation.
- *
+ *
*/
public class BreakpointTests extends TestCase {
- IWorkspace workspace;
- IWorkspaceRoot root;
- static ICProject testProject=null;
- NullProgressMonitor monitor;
- static ICDISession session=null;
+
+ IWorkspace workspace;
+ IWorkspaceRoot root;
+ static ICProject testProject = null;
+ NullProgressMonitor monitor;
+ static ICDISession session = null;
static ICDITarget targets[] = null;
-
-
- /**
- * Constructor for BreakpointTests
- * @param name
- */
- public BreakpointTests(String name) {
- super(name);
- /***
- * The tests assume that they have a working workspace
- * and workspace root object to use to create projects/files in,
- * so we need to get them setup first.
- */
- workspace= ResourcesPlugin.getWorkspace();
- root= workspace.getRoot();
- monitor = new NullProgressMonitor();
- if (workspace==null)
- fail("Workspace was not setup");
- if (root==null)
- fail("Workspace root was not setup");
-
- }
-
- /**
- * Sets up the test fixture.
- *
- * Called before every test case method.
- *
- * Example code test the packages in the project
- * "com.qnx.tools.ide.cdt.core"
- */
- protected static void oneTimeSetUp() throws CoreException, InvocationTargetException, IOException {
+
+ /**
+ * Constructor for BreakpointTests
+ *
+ * @param name
+ */
+ public BreakpointTests(String name) {
+ super(name);
+ /***********************************************************************
+ * The tests assume that they have a working workspace and workspace
+ * root object to use to create projects/files in, so we need to get
+ * them setup first.
+ */
+ workspace = ResourcesPlugin.getWorkspace();
+ root = workspace.getRoot();
+ monitor = new NullProgressMonitor();
+ if (workspace == null)
+ fail("Workspace was not setup");
+ if (root == null)
+ fail("Workspace root was not setup");
+
+ }
+
+ /**
+ * Sets up the test fixture.
+ *
+ * Called before every test case method.
+ *
+ * Example code test the packages in the project
+ * "com.qnx.tools.ide.cdt.core"
+ */
+ protected static void oneTimeSetUp() throws CoreException, InvocationTargetException, IOException {
ResourcesPlugin.getWorkspace().getDescription().setAutoBuilding(false);
- /***
+ /***********************************************************************
* Create a new project and import the test source.
*/
- String pluginRoot=org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.debug.ui.tests").find(new Path("/")).getFile();
- pluginRoot=pluginRoot+"resources/debugTest.zip";
- testProject=CProjectHelper.createCProjectWithImport("filetest", pluginRoot);
- if (testProject==null)
- fail("Unable to create project");
+ Path imputFile = new Path("resources/debugTest.zip");
+ testProject = CProjectHelper.createCProjectWithImport("filetest", imputFile);
+ if (testProject == null)
+ fail("Unable to create project");
/* Build the test project.. */
testProject.getProject().build(IncrementalProjectBuilder.FULL_BUILD, null);
}
- /**
+
+ /**
* Tears down the test fixture.
- *
+ *
* Called after every test case method.
*/
protected void tearDown() throws CoreException {
- if (targets!=null) {
+ if (targets != null) {
try {
targets[0].terminate();
- targets=null;
- } catch (CDIException e) {}
+ targets = null;
+ } catch (CDIException e) {
+ }
}
- if (session!=null) {
+ if (session != null) {
try {
session.terminate();
- session=null;
- } catch (CDIException e) {}
+ session = null;
+ } catch (CDIException e) {
+ }
}
}
-
- /**
- * Tears down the test fixture.
- *
- * Called after every test case method.
- */
- protected static void oneTimeTearDown() throws CoreException {
- if (targets!=null) {
- try {
+
+ /**
+ * Tears down the test fixture.
+ *
+ * Called after every test case method.
+ */
+ protected static void oneTimeTearDown() throws CoreException {
+ if (targets != null) {
+ try {
targets[0].terminate();
- } catch (CDIException e) {}
- }
- if (session!=null) {
- try {
+ } catch (CDIException e) {
+ }
+ }
+ if (session != null) {
+ try {
session.terminate();
- } catch (CDIException e) {}
- }
- CProjectHelper.delete(testProject);
-
- }
-
- public static Test suite() {
- TestSuite suite= new TestSuite(BreakpointTests.class);
- /***
- * Create a wrapper suite around the test suite we created above to
- * allow us to only do the general setup once for all the tests. This
- * is needed because the creation of the source and target projects
- * takes a long time and we really only need to do it once. We could
- * do the setup in the constructor, but we need to be able to remove
- * everything when we are done.
+ } catch (CDIException e) {
+ }
+ }
+ CProjectHelper.delete(testProject);
+
+ }
+
+ public static Test suite() {
+ TestSuite suite = new TestSuite(BreakpointTests.class);
+ /***********************************************************************
+ * Create a wrapper suite around the test suite we created above to
+ * allow us to only do the general setup once for all the tests. This is
+ * needed because the creation of the source and target projects takes a
+ * long time and we really only need to do it once. We could do the
+ * setup in the constructor, but we need to be able to remove everything
+ * when we are done.
*/
TestSetup wrapper = new TestSetup(suite) {
- protected void setUp() throws FileNotFoundException, IOException, InterruptedException, InvocationTargetException, CoreException {
+ protected void setUp() throws FileNotFoundException, IOException, InterruptedException, InvocationTargetException,
+ CoreException {
oneTimeSetUp();
}
-
+
protected void tearDown() throws FileNotFoundException, IOException, CoreException {
oneTimeTearDown();
}
};
- return(wrapper);
- }
-
-
-
- /***
- * A couple tests to make sure setting breakpoints on functions works as
- * expected.
- */
- public void testFunctionBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
- ICDISession session;
- ICDIBreakpointManager breaks;
- ICDILocation location;
- boolean caught=false;
- session=CDebugHelper.createSession("main", testProject);
- assertNotNull(session);
- breaks=session.getBreakpointManager();
- assertNotNull(breaks);
-
- /**********************************************************************
- * Create a break point on a generic function
- **********************************************************************/
-
- location=breaks.createLocation(null, "func1", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
- /**********************************************************************
- * Create a break point on main
- **********************************************************************/
-
- location=breaks.createLocation(null, "main", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
-
- /**********************************************************************
- * Try to create a break point on a function name that does not exist
- * We expect that this will cause the setLocationBreakpoint to throw
- * a CDIException
- **********************************************************************/
-
- location=breaks.createLocation(null, "badname", 0);
- assertNotNull(location);
- try {
- breaks.setLocationBreakpoint(0, location, null, null);
- } catch (CDIException e) {
- caught=true;
- }
- assertTrue(caught);
-
- breaks.deleteAllBreakpoints();
-
- /**********************************************************************
- * Create a break point on a generic function and see if it will
- * get hit and stop program execution.
- **********************************************************************/
-
- location=breaks.createLocation(null, "func1", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
- targets=session.getTargets();
- /* We better only have one target connected to this session or something
- * is not right...
- */
- assertTrue(targets.length==1);
- /* Resume the target, this should cause it to run till it hits the
- * breakpoint
- */
- targets[0].resume();
- /**
- * Give the process up to 10 seconds to become either terminated or
- * suspended. It sould hit the breakponint almost immediatly so we
- * should only sleep for max 100 ms
- */
- for (int x=0;x<100;x++) {
- if (targets[0].isTerminated() || targets[0].isSuspended())
- break;
- Thread.sleep(100);
- }
- assertTrue(targets[0].isSuspended());
- location=targets[0].getCurrentThread().getStackFrames()[0].getLocation();
- assertTrue(location.getLineNumber()==6);
- assertTrue(location.getFunction().equals("func1"));
- assertTrue(location.getFile().equals("main.c"));
-
- /* clean up the session */
- targets[0].terminate();
- int x=0;
- while ((!targets[0].isTerminated()) && (x<30)) {
- Thread.sleep(100);
- }
- if (!targets[0].isTerminated())
+ return (wrapper);
+ }
+
+ /***************************************************************************
+ * A couple tests to make sure setting breakpoints on functions works as
+ * expected.
+ */
+ public void testFunctionBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
+ ICDISession session;
+ ICDIBreakpointManager breaks;
+ ICDILocation location;
+ boolean caught = false;
+ session = CDebugHelper.createSession("main", testProject);
+ assertNotNull(session);
+ breaks = session.getBreakpointManager();
+ assertNotNull(breaks);
+
+ /***********************************************************************
+ * Create a break point on a generic function
+ **********************************************************************/
+
+ location = breaks.createLocation(null, "func1", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ /***********************************************************************
+ * Create a break point on main
+ **********************************************************************/
+
+ location = breaks.createLocation(null, "main", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ /***********************************************************************
+ * Try to create a break point on a function name that does not exist We
+ * expect that this will cause the setLocationBreakpoint to throw a
+ * CDIException
+ **********************************************************************/
+
+ location = breaks.createLocation(null, "badname", 0);
+ assertNotNull(location);
+ try {
+ breaks.setLocationBreakpoint(0, location, null, null);
+ } catch (CDIException e) {
+ caught = true;
+ }
+ assertTrue(caught);
+
+ breaks.deleteAllBreakpoints();
+
+ /***********************************************************************
+ * Create a break point on a generic function and see if it will get hit
+ * and stop program execution.
+ **********************************************************************/
+
+ location = breaks.createLocation(null, "func1", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+ targets = session.getTargets();
+ /*
+ * We better only have one target connected to this session or something
+ * is not right...
+ */
+ assertTrue(targets.length == 1);
+ /*
+ * Resume the target, this should cause it to run till it hits the
+ * breakpoint
+ */
+ targets[0].resume();
+ /**
+ * Give the process up to 10 seconds to become either terminated or
+ * suspended. It sould hit the breakponint almost immediatly so we
+ * should only sleep for max 100 ms
+ */
+ for (int x = 0; x < 100; x++) {
+ if (targets[0].isTerminated() || targets[0].isSuspended())
+ break;
+ Thread.sleep(100);
+ }
+ assertTrue(targets[0].isSuspended());
+ location = targets[0].getCurrentThread().getStackFrames()[0].getLocation();
+ assertTrue(location.getLineNumber() == 6);
+ assertTrue(location.getFunction().equals("func1"));
+ assertTrue(location.getFile().equals("main.c"));
+
+ /* clean up the session */
+ targets[0].terminate();
+ int x = 0;
+ while ((!targets[0].isTerminated()) && (x < 30)) {
+ Thread.sleep(100);
+ }
+ if (!targets[0].isTerminated())
targets[0].terminate();
- session.terminate();
- session=null;
- targets=null;
-
-
- }
-
- /***
- * A couple tests to make sure setting breakpoints on line numbers works as
- * expected.
- */
- public void testLineBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
- ICDIBreakpointManager breaks;
- ICDILocation location;
- boolean caught=false;
- session=CDebugHelper.createSession("main", testProject);
- assertNotNull(session);
- breaks=session.getBreakpointManager();
- assertNotNull(breaks);
-
- /**********************************************************************
- * Create a break point in a generic function
- **********************************************************************/
- location=breaks.createLocation("main.c", null, 7);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
-
- /**********************************************************************
- * Create a break point in main
- **********************************************************************/
- location=breaks.createLocation("main.c", null, 18);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
-
- /**********************************************************************
- * Try to create a break point on a line that does not exist
- * We expect that this will cause the setLocationBreakpoint to throw
- * a CDIException
- **********************************************************************/
-
- location=breaks.createLocation("main.c", null, 30);
- assertNotNull(location);
- try {
- breaks.setLocationBreakpoint(0, location, null, null);
- } catch (CDIException e) {
- caught=true;
- }
- assertTrue(caught);
-
- caught=false;
- /**********************************************************************
- * Try to create a break point on a line that does not have code on it
- **********************************************************************/
-
- location=breaks.createLocation("main.c", null, 11);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
- /**********************************************************************
- * Create a break point in a generic function without passing the source
- * file name. At the time of writing this would just silently fail, so
- * to make sure it works, we will do it once with a valid line number
- * and once with an invalid line number, and the first should always
- * succeed and the second should always throw an exception.
- **********************************************************************/
- location=breaks.createLocation(null, null, 7);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
- caught=false;
- location=breaks.createLocation(null, null, 30);
- assertNotNull(location);
- try {
- breaks.setLocationBreakpoint(0, location, null, null);
- } catch (CDIException e) {
- caught=true;
- }
- assertTrue("Ignoring line numbers with no file specified?", caught);
-
- breaks.deleteAllBreakpoints();
-
- /**********************************************************************
- * Create a break point on a line number and see if it will
- * get hit and stop program execution.
- **********************************************************************/
-
- location=breaks.createLocation(null, null, 7);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
- targets=session.getTargets();
- /* We better only have one target connected to this session or something
- * is not right...
- */
- assertTrue(targets.length==1);
- /* Resume the target, this should cause it to run till it hits the
- * breakpoint
- */
- targets[0].resume();
- /**
- * Give the process up to 10 seconds to become either terminated or
- * suspended. It sould hit the breakponint almost immediatly so we
- * should only sleep for max 100 ms
- */
- for (int x=0;x<100;x++) {
- if (targets[0].isSuspended() || targets[0].isTerminated())
- break;
- Thread.sleep(100);
- }
- assertTrue("Suspended: " + targets[0].isSuspended() + " Termiunated: " + targets[0].isTerminated(), targets[0].isSuspended());
- location=targets[0].getCurrentThread().getStackFrames()[0].getLocation();
- assertTrue(location.getLineNumber()==7);
- assertTrue(location.getFunction().equals("func1"));
- assertTrue(location.getFile().equals("main.c"));
-
-
- /* clean up the session */
- session.terminate();
- session=null;
- targets=null;
-
- }
- /***
- * A couple tests to make sure getting breakpoints works as expected
- */
- public void testGetBreak() throws CoreException, MIException, IOException, CDIException {
- ICDIBreakpointManager breaks;
- ICDILocation location;
- ICDIBreakpoint[] breakpoints;
- ICDILocationBreakpoint curbreak;
- session=CDebugHelper.createSession("main", testProject);
- assertNotNull(session);
- breaks=session.getBreakpointManager();
- assertNotNull(breaks);
-
- /**********************************************************************
- * Make sure initially we don't have any breakpoints
- **********************************************************************/
- breakpoints=breaks.getBreakpoints();
- assertNotNull(breakpoints);
- assertTrue(breakpoints.length==0);
-
- /**********************************************************************
- * Make sure if we create a simple breakpoint, that we can get it back
- * from the system
- *********************************************************************/
- /* Create a break point on a generic function */
- location=breaks.createLocation("main.c", "func1", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
- breakpoints=breaks.getBreakpoints();
- assertNotNull(breakpoints);
- assertTrue(breakpoints.length==1);
- if (breakpoints[0] instanceof ICDILocationBreakpoint) {
- curbreak=(ICDILocationBreakpoint) breakpoints[0];
- } else
- curbreak=null;
- assertNotNull(curbreak);
-
- assertTrue(curbreak.getLocation().equals(location));
-
- /**********************************************************************
- * Make sure if we create multiple break points that we can still
- * get them all back from the system,
- **********************************************************************/
- /* Create another break point on main */
- location=breaks.createLocation("main.c", "main", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, null, null);
-
- breakpoints=breaks.getBreakpoints();
- assertNotNull(breakpoints);
- assertTrue(breakpoints.length==2);
- if (breakpoints[1] instanceof ICDILocationBreakpoint) {
- curbreak=(ICDILocationBreakpoint) breakpoints[1];
- } else
- curbreak=null;
- assertNotNull(curbreak);
- /* Make sure the location still looks like we expect it to..
- . */
- assertTrue(curbreak.getLocation().equals(location));
-
- breaks.deleteAllBreakpoints();
-
-
- /* clean up the session */
- session.terminate();
- session=null;
-
- }
-
- /***
- * A couple tests to make sure deleting breakpoints works as expected
- */
- public void testDelBreak() throws CoreException, MIException, IOException, CDIException {
- ICDIBreakpointManager breaks;
- ICDILocation location, savedLocation;
- ICDIBreakpoint[] breakpoints, savedbreakpoints;
- ICDILocationBreakpoint curbreak;
-
- session=CDebugHelper.createSession("main", testProject);
- assertNotNull(session);
- breaks=session.getBreakpointManager();
- assertNotNull(breaks);
-
- /* Make sure initially we don't have any breakpoints */
- breakpoints=breaks.getBreakpoints();
- assertNotNull(breakpoints);
- assertTrue(breakpoints.length==0);
-
- /**********************************************************************
- *
- * Test to make sure if we create a new breakpoint, we can delete
- * it by passing a refrence to it to deleteBreakpoint()
- *
- **********************************************************************/
-
- /* Create a break point on a generic function */
- location=breaks.createLocation("main.c", "func1", 0);
- assertNotNull(location);
- curbreak=breaks.setLocationBreakpoint(0, location, null, null);
- breaks.deleteBreakpoint(curbreak);
- pause();
- /**
- * we should not have any breakpoints left.
- */
- breakpoints=breaks.getBreakpoints();
- assertTrue(breakpoints.length==0);
-
- /**********************************************************************
- *
- * Test to make sure if we create multiple new breakpoint, we can delete
- * one of them by passing a refrence to it to deleteBreakpoint()
- *
- **********************************************************************/
-
- /* Create a break point on a generic function */
- location=breaks.createLocation("main.c", "func1", 0);
- assertNotNull(location);
- curbreak=breaks.setLocationBreakpoint(0, location, null, null);
- savedLocation=curbreak.getLocation();
-
- location=breaks.createLocation("main.c", "main", 0);
- assertNotNull(location);
- curbreak=breaks.setLocationBreakpoint(0, location, null, null);
- breaks.deleteBreakpoint(curbreak);
+ session.terminate();
+ session = null;
+ targets = null;
+
+ }
+
+ /***************************************************************************
+ * A couple tests to make sure setting breakpoints on line numbers works as
+ * expected.
+ */
+ public void testLineBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
+ ICDIBreakpointManager breaks;
+ ICDILocation location;
+ boolean caught = false;
+ session = CDebugHelper.createSession("main", testProject);
+ assertNotNull(session);
+ breaks = session.getBreakpointManager();
+ assertNotNull(breaks);
+
+ /***********************************************************************
+ * Create a break point in a generic function
+ **********************************************************************/
+ location = breaks.createLocation("main.c", null, 7);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ /***********************************************************************
+ * Create a break point in main
+ **********************************************************************/
+ location = breaks.createLocation("main.c", null, 18);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ /***********************************************************************
+ * Try to create a break point on a line that does not exist We expect
+ * that this will cause the setLocationBreakpoint to throw a
+ * CDIException
+ **********************************************************************/
+
+ location = breaks.createLocation("main.c", null, 30);
+ assertNotNull(location);
+ try {
+ breaks.setLocationBreakpoint(0, location, null, null);
+ } catch (CDIException e) {
+ caught = true;
+ }
+ assertTrue(caught);
+
+ caught = false;
+ /***********************************************************************
+ * Try to create a break point on a line that does not have code on it
+ **********************************************************************/
+
+ location = breaks.createLocation("main.c", null, 11);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ /***********************************************************************
+ * Create a break point in a generic function without passing the source
+ * file name. At the time of writing this would just silently fail, so
+ * to make sure it works, we will do it once with a valid line number
+ * and once with an invalid line number, and the first should always
+ * succeed and the second should always throw an exception.
+ **********************************************************************/
+ location = breaks.createLocation(null, null, 7);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+ caught = false;
+ location = breaks.createLocation(null, null, 30);
+ assertNotNull(location);
+ try {
+ breaks.setLocationBreakpoint(0, location, null, null);
+ } catch (CDIException e) {
+ caught = true;
+ }
+ assertTrue("Ignoring line numbers with no file specified?", caught);
+
+ breaks.deleteAllBreakpoints();
+
+ /***********************************************************************
+ * Create a break point on a line number and see if it will get hit and
+ * stop program execution.
+ **********************************************************************/
+
+ location = breaks.createLocation(null, null, 7);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+ targets = session.getTargets();
+ /*
+ * We better only have one target connected to this session or something
+ * is not right...
+ */
+ assertTrue(targets.length == 1);
+ /*
+ * Resume the target, this should cause it to run till it hits the
+ * breakpoint
+ */
+ targets[0].resume();
+ /**
+ * Give the process up to 10 seconds to become either terminated or
+ * suspended. It sould hit the breakponint almost immediatly so we
+ * should only sleep for max 100 ms
+ */
+ for (int x = 0; x < 100; x++) {
+ if (targets[0].isSuspended() || targets[0].isTerminated())
+ break;
+ Thread.sleep(100);
+ }
+ assertTrue("Suspended: " + targets[0].isSuspended() + " Termiunated: " + targets[0].isTerminated(), targets[0]
+ .isSuspended());
+ location = targets[0].getCurrentThread().getStackFrames()[0].getLocation();
+ assertTrue(location.getLineNumber() == 7);
+ assertTrue(location.getFunction().equals("func1"));
+ assertTrue(location.getFile().equals("main.c"));
+
+ /* clean up the session */
+ session.terminate();
+ session = null;
+ targets = null;
+
+ }
+
+ /***************************************************************************
+ * A couple tests to make sure getting breakpoints works as expected
+ */
+ public void testGetBreak() throws CoreException, MIException, IOException, CDIException {
+ ICDIBreakpointManager breaks;
+ ICDILocation location;
+ ICDIBreakpoint[] breakpoints;
+ ICDILocationBreakpoint curbreak;
+ session = CDebugHelper.createSession("main", testProject);
+ assertNotNull(session);
+ breaks = session.getBreakpointManager();
+ assertNotNull(breaks);
+
+ /***********************************************************************
+ * Make sure initially we don't have any breakpoints
+ **********************************************************************/
+ breakpoints = breaks.getBreakpoints();
+ assertNotNull(breakpoints);
+ assertTrue(breakpoints.length == 0);
+
+ /***********************************************************************
+ * Make sure if we create a simple breakpoint, that we can get it back
+ * from the system
+ **********************************************************************/
+ /* Create a break point on a generic function */
+ location = breaks.createLocation("main.c", "func1", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ breakpoints = breaks.getBreakpoints();
+ assertNotNull(breakpoints);
+ assertTrue(breakpoints.length == 1);
+ if (breakpoints[0] instanceof ICDILocationBreakpoint) {
+ curbreak = (ICDILocationBreakpoint) breakpoints[0];
+ } else
+ curbreak = null;
+ assertNotNull(curbreak);
+
+ assertTrue(curbreak.getLocation().equals(location));
+
+ /***********************************************************************
+ * Make sure if we create multiple break points that we can still get
+ * them all back from the system,
+ **********************************************************************/
+ /* Create another break point on main */
+ location = breaks.createLocation("main.c", "main", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, null, null);
+
+ breakpoints = breaks.getBreakpoints();
+ assertNotNull(breakpoints);
+ assertTrue(breakpoints.length == 2);
+ if (breakpoints[1] instanceof ICDILocationBreakpoint) {
+ curbreak = (ICDILocationBreakpoint) breakpoints[1];
+ } else
+ curbreak = null;
+ assertNotNull(curbreak);
+ /*
+ * Make sure the location still looks like we expect it to.. .
+ */
+ assertTrue(curbreak.getLocation().equals(location));
+
+ breaks.deleteAllBreakpoints();
+
+ /* clean up the session */
+ session.terminate();
+ session = null;
+
+ }
+
+ /***************************************************************************
+ * A couple tests to make sure deleting breakpoints works as expected
+ */
+ public void testDelBreak() throws CoreException, MIException, IOException, CDIException {
+ ICDIBreakpointManager breaks;
+ ICDILocation location, savedLocation;
+ ICDIBreakpoint[] breakpoints, savedbreakpoints;
+ ICDILocationBreakpoint curbreak;
+
+ session = CDebugHelper.createSession("main", testProject);
+ assertNotNull(session);
+ breaks = session.getBreakpointManager();
+ assertNotNull(breaks);
+
+ /* Make sure initially we don't have any breakpoints */
+ breakpoints = breaks.getBreakpoints();
+ assertNotNull(breakpoints);
+ assertTrue(breakpoints.length == 0);
+
+ /***********************************************************************
+ *
+ * Test to make sure if we create a new breakpoint, we can delete it by
+ * passing a refrence to it to deleteBreakpoint()
+ *
+ **********************************************************************/
+
+ /* Create a break point on a generic function */
+ location = breaks.createLocation("main.c", "func1", 0);
+ assertNotNull(location);
+ curbreak = breaks.setLocationBreakpoint(0, location, null, null);
+ breaks.deleteBreakpoint(curbreak);
pause();
- breakpoints=breaks.getBreakpoints();
- /***
- * Make sure there is only 1 breakpoint left, and it's the one we expect
- */
- assertTrue(breakpoints.length==1);
- curbreak=(ICDILocationBreakpoint) breakpoints[0];
- assertNotNull(curbreak);
- assertTrue(curbreak.getLocation().equals(savedLocation));
- /***
- * Then delete the other breakpoint.
- */
- breaks.deleteBreakpoint(curbreak);
+ /**
+ * we should not have any breakpoints left.
+ */
+ breakpoints = breaks.getBreakpoints();
+ assertTrue(breakpoints.length == 0);
+
+ /***********************************************************************
+ *
+ * Test to make sure if we create multiple new breakpoint, we can delete
+ * one of them by passing a refrence to it to deleteBreakpoint()
+ *
+ **********************************************************************/
+
+ /* Create a break point on a generic function */
+ location = breaks.createLocation("main.c", "func1", 0);
+ assertNotNull(location);
+ curbreak = breaks.setLocationBreakpoint(0, location, null, null);
+ savedLocation = curbreak.getLocation();
+
+ location = breaks.createLocation("main.c", "main", 0);
+ assertNotNull(location);
+ curbreak = breaks.setLocationBreakpoint(0, location, null, null);
+ breaks.deleteBreakpoint(curbreak);
pause();
- breakpoints=breaks.getBreakpoints();
- assertTrue(breakpoints.length==0);
-
- /**********************************************************************
- * Make sure deleteBreakpoints works when given 1 breakpoint to delete
- **********************************************************************/
- savedbreakpoints= new ICDIBreakpoint[1];
- for (int x=0;x<10;x++) {
- location=breaks.createLocation("main.c", null, x+1);
- savedbreakpoints[0]=breaks.setLocationBreakpoint(0, location, null, null);
- assertNotNull(savedbreakpoints[0]);
- }
- breaks.deleteBreakpoints(savedbreakpoints);
+ breakpoints = breaks.getBreakpoints();
+ /***********************************************************************
+ * Make sure there is only 1 breakpoint left, and it's the one we expect
+ */
+ assertTrue(breakpoints.length == 1);
+ curbreak = (ICDILocationBreakpoint) breakpoints[0];
+ assertNotNull(curbreak);
+ assertTrue(curbreak.getLocation().equals(savedLocation));
+ /***********************************************************************
+ * Then delete the other breakpoint.
+ */
+ breaks.deleteBreakpoint(curbreak);
+ pause();
+ breakpoints = breaks.getBreakpoints();
+ assertTrue(breakpoints.length == 0);
+
+ /***********************************************************************
+ * Make sure deleteBreakpoints works when given 1 breakpoint to delete
+ **********************************************************************/
+ savedbreakpoints = new ICDIBreakpoint[1];
+ for (int x = 0; x < 10; x++) {
+ location = breaks.createLocation("main.c", null, x + 1);
+ savedbreakpoints[0] = breaks.setLocationBreakpoint(0, location, null, null);
+ assertNotNull(savedbreakpoints[0]);
+ }
+ breaks.deleteBreakpoints(savedbreakpoints);
pause();
- /* We should now have 9 breakpoints left. */
- breakpoints=breaks.getBreakpoints();
- assertTrue(breakpoints.length==9);
- /* Make sure we have the correct 9 breakpoints left */
- for (int x=0;x<breakpoints.length;x++) {
- curbreak=(ICDILocationBreakpoint)breakpoints[x];
- assertTrue(curbreak.getLocation().getLineNumber()==x+1);
- }
- breaks.deleteAllBreakpoints();
+ /* We should now have 9 breakpoints left. */
+ breakpoints = breaks.getBreakpoints();
+ assertTrue(breakpoints.length == 9);
+ /* Make sure we have the correct 9 breakpoints left */
+ for (int x = 0; x < breakpoints.length; x++) {
+ curbreak = (ICDILocationBreakpoint) breakpoints[x];
+ assertTrue(curbreak.getLocation().getLineNumber() == x + 1);
+ }
+ breaks.deleteAllBreakpoints();
pause();
- assertTrue(breaks.getBreakpoints().length==0);
-
- /**********************************************************************
- * Make sure deleteBreakpoints works when given more then 1 but less
- * then all breakpoints to delete
- **********************************************************************/
- savedbreakpoints= new ICDIBreakpoint[4];
- for (int x=0;x<10;x++) {
- location=breaks.createLocation("main.c", null, x+1);
- savedbreakpoints[x%4]=breaks.setLocationBreakpoint(0, location, null, null);
- assertNotNull(savedbreakpoints[x%4]);
- }
- breaks.deleteBreakpoints(savedbreakpoints);
+ assertTrue(breaks.getBreakpoints().length == 0);
+
+ /***********************************************************************
+ * Make sure deleteBreakpoints works when given more then 1 but less
+ * then all breakpoints to delete
+ **********************************************************************/
+ savedbreakpoints = new ICDIBreakpoint[4];
+ for (int x = 0; x < 10; x++) {
+ location = breaks.createLocation("main.c", null, x + 1);
+ savedbreakpoints[x % 4] = breaks.setLocationBreakpoint(0, location, null, null);
+ assertNotNull(savedbreakpoints[x % 4]);
+ }
+ breaks.deleteBreakpoints(savedbreakpoints);
pause();
-
- /* We should now have 6 breakpoints left. */
- breakpoints=breaks.getBreakpoints();
- assertTrue(breakpoints.length==6);
- /* Make sure we have the correct 6 breakpoints left */
- for (int x=0;x<breakpoints.length;x++) {
- curbreak=(ICDILocationBreakpoint)breakpoints[x];
- assertTrue(curbreak.getLocation().getLineNumber()==x+1);
- }
- breaks.deleteAllBreakpoints();
+
+ /* We should now have 6 breakpoints left. */
+ breakpoints = breaks.getBreakpoints();
+ assertTrue(breakpoints.length == 6);
+ /* Make sure we have the correct 6 breakpoints left */
+ for (int x = 0; x < breakpoints.length; x++) {
+ curbreak = (ICDILocationBreakpoint) breakpoints[x];
+ assertTrue(curbreak.getLocation().getLineNumber() == x + 1);
+ }
+ breaks.deleteAllBreakpoints();
pause();
- assertTrue(breaks.getBreakpoints().length==0);
-
- /**********************************************************************
- * Make sure deleteBreakpoints works when given all the breakpoints
- **********************************************************************/
- savedbreakpoints= new ICDIBreakpoint[10];
- for (int x=0;x<10;x++) {
- location=breaks.createLocation("main.c", null, x+1);
- savedbreakpoints[x]=breaks.setLocationBreakpoint(0, location, null, null);
- assertNotNull(savedbreakpoints[x]);
- }
- breaks.deleteBreakpoints(savedbreakpoints);
+ assertTrue(breaks.getBreakpoints().length == 0);
+
+ /***********************************************************************
+ * Make sure deleteBreakpoints works when given all the breakpoints
+ **********************************************************************/
+ savedbreakpoints = new ICDIBreakpoint[10];
+ for (int x = 0; x < 10; x++) {
+ location = breaks.createLocation("main.c", null, x + 1);
+ savedbreakpoints[x] = breaks.setLocationBreakpoint(0, location, null, null);
+ assertNotNull(savedbreakpoints[x]);
+ }
+ breaks.deleteBreakpoints(savedbreakpoints);
pause();
- /* We should now have 0 breakpoints left. */
- breakpoints=breaks.getBreakpoints();
- assertTrue(breakpoints.length==0);
-
- /**********************************************************************
- * Make sure deleteAllBreakpoints works
- **********************************************************************/
-
- for (int x=0;x<10;x++) {
- location=breaks.createLocation("main.c", null, x+1);
- curbreak=breaks.setLocationBreakpoint(0, location, null, null);
- assertNotNull(curbreak);
- }
- breaks.deleteAllBreakpoints();
+ /* We should now have 0 breakpoints left. */
+ breakpoints = breaks.getBreakpoints();
+ assertTrue(breakpoints.length == 0);
+
+ /***********************************************************************
+ * Make sure deleteAllBreakpoints works
+ **********************************************************************/
+
+ for (int x = 0; x < 10; x++) {
+ location = breaks.createLocation("main.c", null, x + 1);
+ curbreak = breaks.setLocationBreakpoint(0, location, null, null);
+ assertNotNull(curbreak);
+ }
+ breaks.deleteAllBreakpoints();
pause();
- /* We should now have 0 breakpoints left. */
- breakpoints=breaks.getBreakpoints();
- assertTrue(breakpoints.length==0);
-
-
-
- /* clean up the session */
- session.terminate();
- session=null;
-
- }
- /***
- * A couple tests to make sure setting breakpoints with conditions seems to
- * work as expected.
- */
- public void testCondBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
- ICDIBreakpointManager breaks;
- ICDILocation location;
- ICDICondition cond;
- boolean caught=false;
- session=CDebugHelper.createSession("main", testProject);
- assertNotNull(session);
- breaks=session.getBreakpointManager();
- assertNotNull(breaks);
-
- /**********************************************************************
- * Create a break point on a generic function with an empty condition
- **********************************************************************/
- cond=breaks.createCondition(0, "");
- location=breaks.createLocation(null, "func1", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, cond, null);
-
- /**********************************************************************
- * Create a break point on a generic function with an valid condition
- **********************************************************************/
- cond=breaks.createCondition(0, "x<10");
- location=breaks.createLocation(null, "func1", 0);
- assertNotNull(location);
- breaks.setLocationBreakpoint(0, location, cond, null);
-
- /**********************************************************************
- * Create a break point on a generic function with an invalid condition
- * We expect to get a CDIException when we try to set the breakpoint.
- **********************************************************************/
- cond=breaks.createCondition(0, "nonexist<10");
- location=breaks.createLocation(null, "func1", 0);
- assertNotNull(location);
- try {
- breaks.setLocationBreakpoint(0, location, cond, null);
- } catch (CDIException e) {
- caught=true;
- }
- assertTrue(caught);
-
- /**********************************************************************
- * Create a break point on a line number with a condition and make sure
- * it does not suspend execution of the application until the condition
- * is true
- **********************************************************************/
- breaks.deleteAllBreakpoints();
- location=breaks.createLocation(null, null, 23);
- assertNotNull(location);
- cond=breaks.createCondition(0, "a>10");
-
- breaks.setLocationBreakpoint(0, location, cond, null);
- targets=session.getTargets();
- /* We better only have one target connected to this session or something
- * is not right...
- */
- assertTrue(targets.length==1);
- /* Resume the target, this should cause it to run till it hits the
- * breakpoint
- */
- targets[0].resume();
- /**
- * Give the process up to 10 seconds to become either terminated or
- * suspended. It sould hit the breakponint almost immediatly so we
- * should only sleep for max 100 ms
- */
- for (int x=0;x<100;x++) {
- if (targets[0].isSuspended() || targets[0].isTerminated())
- break;
- Thread.sleep(100);
- }
- assertTrue("Suspended: " + targets[0].isSuspended() + " Termiunated: " + targets[0].isTerminated(), targets[0].isSuspended());
- location=targets[0].getCurrentThread().getStackFrames()[0].getLocation();
- assertTrue(location.getLineNumber()==23);
- assertTrue(location.getFunction().equals("main"));
- assertTrue(location.getFile().equals("main.c"));
- /* Get the value of a and and make sure it is 11 */
- assertTrue(targets[0].evaluateExpressionToString("a"),
- targets[0].evaluateExpressionToString("a").equals("11"));
-
-
- /* clean up the session */
- session.terminate();
- session=null;
- targets=null;
-
- }
- void pause() {
- try {
- Thread.sleep(100);
- } catch (InterruptedException e) {
+ /* We should now have 0 breakpoints left. */
+ breakpoints = breaks.getBreakpoints();
+ assertTrue(breakpoints.length == 0);
+
+ /* clean up the session */
+ session.terminate();
+ session = null;
+
+ }
+
+ /***************************************************************************
+ * A couple tests to make sure setting breakpoints with conditions seems to
+ * work as expected.
+ */
+ public void testCondBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
+ ICDIBreakpointManager breaks;
+ ICDILocation location;
+ ICDICondition cond;
+ boolean caught = false;
+ session = CDebugHelper.createSession("main", testProject);
+ assertNotNull(session);
+ breaks = session.getBreakpointManager();
+ assertNotNull(breaks);
+
+ /***********************************************************************
+ * Create a break point on a generic function with an empty condition
+ **********************************************************************/
+ cond = breaks.createCondition(0, "");
+ location = breaks.createLocation(null, "func1", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, cond, null);
+
+ /***********************************************************************
+ * Create a break point on a generic function with an valid condition
+ **********************************************************************/
+ cond = breaks.createCondition(0, "x<10");
+ location = breaks.createLocation(null, "func1", 0);
+ assertNotNull(location);
+ breaks.setLocationBreakpoint(0, location, cond, null);
+
+ /***********************************************************************
+ * Create a break point on a generic function with an invalid condition
+ * We expect to get a CDIException when we try to set the breakpoint.
+ **********************************************************************/
+ cond = breaks.createCondition(0, "nonexist<10");
+ location = breaks.createLocation(null, "func1", 0);
+ assertNotNull(location);
+ try {
+ breaks.setLocationBreakpoint(0, location, cond, null);
+ } catch (CDIException e) {
+ caught = true;
+ }
+ assertTrue(caught);
+
+ /***********************************************************************
+ * Create a break point on a line number with a condition and make sure
+ * it does not suspend execution of the application until the condition
+ * is true
+ **********************************************************************/
+ breaks.deleteAllBreakpoints();
+ location = breaks.createLocation(null, null, 23);
+ assertNotNull(location);
+ cond = breaks.createCondition(0, "a>10");
+
+ breaks.setLocationBreakpoint(0, location, cond, null);
+ targets = session.getTargets();
+ /*
+ * We better only have one target connected to this session or something
+ * is not right...
+ */
+ assertTrue(targets.length == 1);
+ /*
+ * Resume the target, this should cause it to run till it hits the
+ * breakpoint
+ */
+ targets[0].resume();
+ /**
+ * Give the process up to 10 seconds to become either terminated or
+ * suspended. It sould hit the breakponint almost immediatly so we
+ * should only sleep for max 100 ms
+ */
+ for (int x = 0; x < 100; x++) {
+ if (targets[0].isSuspended() || targets[0].isTerminated())
+ break;
+ Thread.sleep(100);
+ }
+ assertTrue("Suspended: " + targets[0].isSuspended() + " Termiunated: " + targets[0].isTerminated(), targets[0]
+ .isSuspended());
+ location = targets[0].getCurrentThread().getStackFrames()[0].getLocation();
+ assertTrue(location.getLineNumber() == 23);
+ assertTrue(location.getFunction().equals("main"));
+ assertTrue(location.getFile().equals("main.c"));
+ /* Get the value of a and and make sure it is 11 */
+ assertTrue(targets[0].evaluateExpressionToString("a"), targets[0].evaluateExpressionToString("a").equals("11"));
+
+ /* clean up the session */
+ session.terminate();
+ session = null;
+ targets = null;
+
+ }
+
+ void pause() {
+ try {
+ Thread.sleep(100);
+ } catch (InterruptedException e) {
+ }
}
- }
-}
+} \ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/DebugTests.java b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/DebugTests.java
index 1d41d21aa87..6d841b05dfc 100644
--- a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/DebugTests.java
+++ b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/DebugTests.java
@@ -26,6 +26,7 @@ import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
@@ -78,9 +79,8 @@ public class DebugTests extends TestCase {
/***
* Create a new project and import the test source.
*/
- String pluginRoot=org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.debug.ui.tests").find(new Path("/")).getFile();
- pluginRoot=pluginRoot+"resources/debugTest.zip";
- testProject=CProjectHelper.createCProjectWithImport("filetest", pluginRoot);
+ IPath importFile = new Path("resources/debugTest.zip");
+ testProject=CProjectHelper.createCProjectWithImport("filetest", importFile);
if (testProject==null)
fail("Unable to create project");
/* Build the test project.. */
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/LocationTests.java b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/LocationTests.java
index 03594819ab6..b3bdccab083 100644
--- a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/LocationTests.java
+++ b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/LocationTests.java
@@ -27,6 +27,7 @@ import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
@@ -79,9 +80,8 @@ public class LocationTests extends TestCase {
/***
* Create a new project and import the test source.
*/
- String pluginRoot=org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.debug.ui.tests").find(new Path("/")).getFile();
- pluginRoot=pluginRoot+"resources/debugTest.zip";
- testProject=CProjectHelper.createCProjectWithImport("filetest", pluginRoot);
+ IPath importFile = new Path("resources/debugTest.zip");
+ testProject=CProjectHelper.createCProjectWithImport("filetest", importFile);
if (testProject==null)
fail("Unable to create project");
/* Build the test project.. */

Back to the top