diff options
Diffstat (limited to 'debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java')
| -rw-r--r-- | debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java | 616 |
1 files changed, 0 insertions, 616 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 deleted file mode 100644 index d7acdc6bded..00000000000 --- a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java +++ /dev/null @@ -1,616 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2000, 2012 QNX Software Systems 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: - * QNX Software Systems - Initial API and implementation - *******************************************************************************/ -package org.eclipse.cdt.debug.core.tests; - -import java.io.IOException; -import java.math.BigInteger; - -import junit.framework.Test; - -import org.eclipse.cdt.debug.core.cdi.CDIException; -import org.eclipse.cdt.debug.core.cdi.ICDIAddressLocation; -import org.eclipse.cdt.debug.core.cdi.ICDICondition; -import org.eclipse.cdt.debug.core.cdi.ICDIFunctionLocation; -import org.eclipse.cdt.debug.core.cdi.ICDILineLocation; -import org.eclipse.cdt.debug.core.cdi.ICDILocator; -import org.eclipse.cdt.debug.core.cdi.model.ICDIBreakpoint; -import org.eclipse.cdt.debug.core.cdi.model.ICDILocationBreakpoint; -import org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame; -import org.eclipse.cdt.debug.core.cdi.model.ICDITarget; -import org.eclipse.cdt.debug.mi.core.MIException; -import org.eclipse.core.runtime.CoreException; - -/** - * @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 AbstractDebugTest { - - - public static Test suite() { - return new DebugTestWrapper(BreakpointTests.class) {}; - } - @Override - protected void setUp() throws Exception { - super.setUp(); - createDebugSession(); - assertNotNull(currentTarget); - currentTarget.deleteAllBreakpoints(); - pause(); - } - @Override - protected void tearDown() throws Exception { - /* 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(); - super.tearDown(); - } - - - /*************************************************************************** - * A couple tests to make sure setting breakpoints on functions works as - * expected. - */ - public void testFunctionBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException { - - ICDITarget cdiTarget = currentTarget; - ICDIFunctionLocation location; - boolean caught = false; - - - /*********************************************************************** - * Create a break point on a generic function - **********************************************************************/ - - location = cdiTarget.createFunctionLocation(null, "func1"); //$NON-NLS-1$ - assertNotNull(location); - cdiTarget.setFunctionBreakpoint(0, location, null, false); - - /*********************************************************************** - * Create a break point on main - **********************************************************************/ - - location = cdiTarget.createFunctionLocation(null, "main"); //$NON-NLS-1$ - assertNotNull(location); - cdiTarget.setFunctionBreakpoint(0, location, null, false); - - /*********************************************************************** - * 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 = cdiTarget.createFunctionLocation(null, "badname"); //$NON-NLS-1$ - assertNotNull(location); - try { - cdiTarget.setFunctionBreakpoint(0, location, null, false); - } catch (CDIException e) { - caught = true; - } - assertTrue(caught); - - cdiTarget.deleteAllBreakpoints(); - - /*********************************************************************** - * Create a break point on a generic function and see if it will get hit - * and stop program execution. - **********************************************************************/ - - location = cdiTarget.createFunctionLocation(null, "func1"); //$NON-NLS-1$ - assertNotNull(location); - cdiTarget.setFunctionBreakpoint(0, location, null, false); - 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 - */ - resumeCurrentTarget(); - /** - * 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 - */ - waitSuspend(cdiTarget); - ICDILocator locator = getCurrentLocator(); - assertTrue(locator.getLineNumber() == 6); - assertTrue(locator.getFunction().equals("func1")); //$NON-NLS-1$ - assertTrue(locator.getFile().endsWith("main.c")); //$NON-NLS-1$ - } - - /*************************************************************************** - * A couple tests to make sure setting breakpoints on line numbers works as - * expected. - */ - public void testLineBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException { - ICDITarget cdiTarget = currentTarget; - ICDILineLocation location; - boolean caught = false; - - - /*********************************************************************** - * Create a break point in a generic function - **********************************************************************/ - location = cdiTarget.createLineLocation("main.c", 7); - assertNotNull(location); - cdiTarget.setLineBreakpoint(0, location, null, false); - - /*********************************************************************** - * Create a break point in main - **********************************************************************/ - location = cdiTarget.createLineLocation("main.c", 18); - assertNotNull(location); - cdiTarget.setLineBreakpoint(0, location, null, false); - - /*********************************************************************** - * 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 = cdiTarget.createLineLocation("main.c", 30); - assertNotNull(location); - try { - cdiTarget.setLineBreakpoint(0, location, null, false); - } 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 = cdiTarget.createLineLocation("main.c", 11); - assertNotNull(location); - cdiTarget.setLineBreakpoint(0, location, null, false); - - /*********************************************************************** - * 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 = cdiTarget.createLineLocation(null, 7); - assertNotNull(location); - cdiTarget.setLineBreakpoint(0, location, null, false); - caught = false; - location = cdiTarget.createLineLocation(null, 30); - assertNotNull(location); - try { - cdiTarget.setLineBreakpoint(0, location, null, false); - } catch (CDIException e) { - caught = true; - } - assertTrue("Ignoring line numbers with no file specified?", caught); - - cdiTarget.deleteAllBreakpoints(); - - /*********************************************************************** - * Create a break point on a line number and see if it will get hit and - * stop program execution. - **********************************************************************/ - - location = cdiTarget.createLineLocation(null, 7); - assertNotNull(location); - cdiTarget.setLineBreakpoint(0, location, null, false); - 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()); - ICDILocator locator = getCurrentLocator(); - assertTrue(locator.getLineNumber() == 7); - assertTrue(locator.getFunction().equals("func1")); - assertTrue(locator.getFile().endsWith("main.c")); - - } - - /*************************************************************************** - * A couple tests to make sure getting breakpoints works as expected - */ - public void testGetBreak() throws CoreException, MIException, IOException, CDIException { - ICDITarget cdiTarget = currentTarget; - ICDIFunctionLocation location; - ICDIBreakpoint[] breakpoints; - ICDILocationBreakpoint curbreak; - - - /*********************************************************************** - * Make sure initially we don't have any breakpoints - **********************************************************************/ - breakpoints = cdiTarget.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 = cdiTarget.createFunctionLocation("main.c", "func1"); - assertNotNull(location); - cdiTarget.setFunctionBreakpoint(0, location, null, false); - - breakpoints = cdiTarget.getBreakpoints(); - assertNotNull(breakpoints); - assertTrue(breakpoints.length == 1); - if (breakpoints[0] instanceof ICDILocationBreakpoint) { - curbreak = (ICDILocationBreakpoint) breakpoints[0]; - } else - curbreak = null; - assertNotNull(curbreak); - - //assertTrue(curbreak.getLocator().equals(location)); - { - ICDILocator locator = curbreak.getLocator(); - String file = locator.getFile(); - String function = locator.getFunction(); - assertTrue("main.c".equals(file)); - assertTrue("func1".equals(function)); - } - - /*********************************************************************** - * 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 = cdiTarget.createFunctionLocation("main.c", "main"); - assertNotNull(location); - cdiTarget.setFunctionBreakpoint(0, location, null, false); - - breakpoints = cdiTarget.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)); - { - ICDILocator locator = curbreak.getLocator(); - String file = locator.getFile(); - String function = locator.getFunction(); - assertTrue("main.c".equals(file)); - assertTrue("main".equals(function)); - } - - cdiTarget.deleteAllBreakpoints(); - - - } - - /*************************************************************************** - * A couple tests to make sure deleting breakpoints works as expected - */ - public void testDelBreak() throws CoreException, MIException, IOException, CDIException { - ICDITarget cdiTarget = currentTarget; - ICDIFunctionLocation location; - ICDILocator savedLocation; - ICDIBreakpoint[] breakpoints, savedbreakpoints; - ICDILocationBreakpoint curbreak; - - /* Make sure initially we don't have any breakpoints */ - breakpoints = cdiTarget.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 = cdiTarget.createFunctionLocation("main.c", "func1"); - assertNotNull(location); - curbreak = cdiTarget.setFunctionBreakpoint(0, location, null, false); - cdiTarget.deleteBreakpoints( new ICDIBreakpoint[] { curbreak } ); - pause(); - /** - * we should not have any breakpoints left. - */ - breakpoints = cdiTarget.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 = cdiTarget.createFunctionLocation("main.c", "func1"); - assertNotNull(location); - curbreak = cdiTarget.setFunctionBreakpoint(0, location, null, false); - savedLocation = curbreak.getLocator(); - - location = cdiTarget.createFunctionLocation("main.c", "main"); - assertNotNull(location); - curbreak = cdiTarget.setFunctionBreakpoint(0, location, null, false); - cdiTarget.deleteBreakpoints( new ICDIBreakpoint[] { curbreak } ); - pause(); - breakpoints = cdiTarget.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.getLocator().equals(savedLocation)); - /*********************************************************************** - * Then delete the other breakpoint. - */ - cdiTarget.deleteBreakpoints( new ICDIBreakpoint[] { curbreak } ); - pause(); - breakpoints = cdiTarget.getBreakpoints(); - assertTrue(breakpoints.length == 0); - - /*********************************************************************** - * Make sure deleteBreakpoints works when given 1 breakpoint to delete - **********************************************************************/ - savedbreakpoints = new ICDIBreakpoint[1]; - int lineStart = 6; - int maxBreakpoints = 5; - for (int x = 0; x < maxBreakpoints; x++) { - ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart); - ICDILocationBreakpoint bp = cdiTarget.setLineBreakpoint(0, lineLocation, null, false); - assertNotNull(bp); - assertEquals(x + lineStart, (bp.getLocator().getLineNumber())); - savedbreakpoints[0] = bp; - } - cdiTarget.deleteBreakpoints(savedbreakpoints); - pause(); - /* We should now have N-1 breakpoints left. */ - breakpoints = cdiTarget.getBreakpoints(); - assertTrue(breakpoints.length == maxBreakpoints-1); - /* Make sure we have the correct N-1 breakpoints left, we deleted one at line N */ - for (int x = 0; x < breakpoints.length; x++) { - curbreak = (ICDILocationBreakpoint) breakpoints[x]; - assertNotEquals(((ICDILocationBreakpoint)savedbreakpoints[0]).getLocator().getLineNumber(), curbreak.getLocator().getLineNumber()); - } - cdiTarget.deleteAllBreakpoints(); - pause(); - assertTrue(cdiTarget.getBreakpoints().length == 0); - - /*********************************************************************** - * Make sure deleteBreakpoints works when given more then 1 but less - * then all breakpoints to delete - **********************************************************************/ - savedbreakpoints = new ICDIBreakpoint[2]; - for (int x = 0; x < maxBreakpoints; x++) { - ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart); - savedbreakpoints[x % 2] = cdiTarget.setLineBreakpoint(0, lineLocation, null, false); - assertNotNull(savedbreakpoints[x % 2]); - } - cdiTarget.deleteBreakpoints(savedbreakpoints); - pause(); - - /* We should now have maxBreakpoints-2 breakpoints left. */ - breakpoints = cdiTarget.getBreakpoints(); - assertEquals(maxBreakpoints-2, breakpoints.length ); - /* Make sure we have the correct 6 breakpoints left */ - for (int x = 0; x < breakpoints.length; x++) { - curbreak = (ICDILocationBreakpoint) breakpoints[x]; - assertEquals(x+lineStart, curbreak.getLocator().getLineNumber()); - } - cdiTarget.deleteAllBreakpoints(); - pause(); - assertTrue(cdiTarget.getBreakpoints().length == 0); - - /*********************************************************************** - * Make sure deleteBreakpoints works when given all the breakpoints - **********************************************************************/ - savedbreakpoints = new ICDIBreakpoint[maxBreakpoints]; - for (int x = 0; x < maxBreakpoints; x++) { - ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart); - savedbreakpoints[x] = cdiTarget.setLineBreakpoint(0, lineLocation, null, false); - assertNotNull(savedbreakpoints[x]); - } - cdiTarget.deleteBreakpoints(savedbreakpoints); - pause(); - /* We should now have 0 breakpoints left. */ - breakpoints = cdiTarget.getBreakpoints(); - assertTrue(breakpoints.length == 0); - - /*********************************************************************** - * Make sure deleteAllBreakpoints works - **********************************************************************/ - - for (int x = 0; x < maxBreakpoints; x++) { - ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart); - curbreak = cdiTarget.setLineBreakpoint(0, lineLocation, null, false); - assertNotNull(curbreak); - } - cdiTarget.deleteAllBreakpoints(); - pause(); - /* We should now have 0 breakpoints left. */ - breakpoints = cdiTarget.getBreakpoints(); - assertTrue(breakpoints.length == 0); - - } - - private void assertNotEquals(int notExpected, int actual) { - if (notExpected==actual) - fail("not expected:<"+actual+">"); - - } - /*************************************************************************** - * A couple tests to make sure setting breakpoints with conditions seems to - * work as expected. - */ - public void testCondBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException { - boolean caught = false; - ICDITarget cdiTarget = currentTarget; - ICDICondition cond; - - /*********************************************************************** - * 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 - **********************************************************************/ - cdiTarget.deleteAllBreakpoints(); - pause(); - ICDILineLocation lineLocation = cdiTarget.createLineLocation(null, 23); - assertNotNull(lineLocation); - cond = cdiTarget.createCondition(0, "a>10"); - cdiTarget.setLineBreakpoint(0, lineLocation, cond, false); - pause(); - resumeCurrentTarget(); - /** - * 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 - */ - waitSuspend(cdiTarget); - ICDIStackFrame frame = getCurrentFrame(); - ICDILocator locator = getCurrentLocator(); - assertTrue(locator.getLineNumber() == 23); - assertTrue(locator.getFunction().equals("main")); - assertTrue(locator.getFile().endsWith("main.c")); - /* Get the value of a and and make sure it is 11 */ - assertTrue(targets[0].evaluateExpressionToString(frame, "a"), targets[0].evaluateExpressionToString(frame, "a").equals("11")); - - } - public void testCondBreak2() throws CoreException, MIException, IOException, CDIException, InterruptedException { - - ICDITarget cdiTarget = currentTarget; - - /*********************************************************************** - * Create a break point on a generic function with an empty condition - **********************************************************************/ - ICDICondition cond = cdiTarget.createCondition(0, ""); - ICDIFunctionLocation location = cdiTarget.createFunctionLocation(null, "func1"); - assertNotNull(location); - cdiTarget.setFunctionBreakpoint(0, location, cond, false); - - /*********************************************************************** - * Create a break point on a generic function with an valid condition - **********************************************************************/ - cond = cdiTarget.createCondition(0, "x<10"); - ICDILineLocation location2 = cdiTarget.createLineLocation("main.c", 9); - assertNotNull(location); - cdiTarget.setLineBreakpoint(0, location2, cond, false); - } - - public void testCondBreakError() { - ICDITarget cdiTarget = currentTarget; - ICDICondition cond; - ICDIFunctionLocation location; - /*********************************************************************** - * 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. - **********************************************************************/ - boolean caught = false; - cond = cdiTarget.createCondition(0, "nonexist<10"); - location = cdiTarget.createFunctionLocation(null, "func1"); - assertNotNull(location); - try { - cdiTarget.setFunctionBreakpoint(0, location, cond, false); - } catch (CDIException e) { - caught = true; - } - assertTrue("Setting wrong condition should fail",caught); - } - - public void testHitCond() throws CoreException, MIException, IOException, CDIException, InterruptedException { - setBreakOnMain(); - testCondBreak2(); - resumeCurrentTarget(); - waitSuspend(currentTarget); - } - public void xfail_testHitCondWithError() throws CoreException, MIException, IOException, CDIException, InterruptedException { - // this currently fails sometimes - after set bad breakpoint it does not hit any - // only reproducible when setting invalid condition breakpoint, reason unknown - setBreakOnMain(); - testCondBreak2(); - testCondBreakError(); - pause(); - /* We should now have 3 breakpoints left. */ - ICDIBreakpoint[] breakpoints = currentTarget.getBreakpoints(); - assertTrue(breakpoints.length == 3); - resumeCurrentTarget(); - waitSuspend(currentTarget); - } - /*************************************************************************** - * A test to make sure setting address breakpoints works as - * expected. - */ - public void testAddressBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException { - - - ICDIAddressLocation location; - boolean caught = false; - - setBreakOnMain(); - currentTarget.resume(false); - waitSuspend(currentTarget); - currentTarget.stepOver(1); - pause(); - BigInteger address = getCurrentLocator().getAddress(); - /*********************************************************************** - * Create a break point on first instruction - **********************************************************************/ - - location = currentTarget.createAddressLocation(address); - assertNotNull(location); - currentTarget.setAddressBreakpoint(0, location, null, false); - - // restart - currentTarget.restart(); - pause(); - waitSuspend(currentTarget); - - ICDILocator locator = getCurrentLocator(); - assertTrue(locator.getLineNumber() == 18); - assertTrue(locator.getFunction().equals("main")); //$NON-NLS-1$ - assertTrue(locator.getFile().endsWith("main.c")); //$NON-NLS-1$ - } - -}
\ No newline at end of file |