20th June, 2002
+Eclipse.org makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the +Common Public License Version 1.0 ("CPL"). A copy of the CPL is available at http://www.eclipse.org/legal/cpl-v10.html. +For purposes of the CPL, "Program" will mean the Content.
+ +The Content includes items that may be have been sourced from third parties as follows:
+ +JUnit 3.7
+The plug-in is based on software developed by JUnit.org. Your use of JUnit 3.7 in both source and binary code +form contained in the plug-in is subject to the terms and conditions of the IBM Public License 1.0 which is available at +http://oss.software.ibm.com/developerworks/opensource/license10.html. +The source code is located in testresources/junit37-noUI-src.zip.
+ +i) IBM effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;
+ii) IBM effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;
+iii) IBM states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party.
+ +If this Content is licensed to you under the terms and conditions of the CPL, any Contributions, as defined in the CPL, uploaded, submitted, or otherwise +made available to Eclipse.org, members of Eclipse.org and/or the host of Eclipse.org web site, by you that relate to such +Content are provided under the terms and conditions of the CPL and can be made available to others under the terms of the CPL.
+ +If this Content is licensed to you under license terms and conditions other than the CPL ("Other License"), any modifications, enhancements and/or +other code and/or documentation ("Modifications") uploaded, submitted, or otherwise made available to Eclipse.org, members of Eclipse.org and/or the +host of Eclipse.org, by you that relate to such Content are provided under terms and conditions of the Other License and can be made available +to others under the terms of the Other License. In addition, with regard to Modifications for which you are the copyright holder, you are also +providing the Modifications under the terms and conditions of the CPL and such Modifications can be made available to others under the terms of +the CPL.
+ + + \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.ui.tests/build.properties b/debug/org.eclipse.cdt.debug.ui.tests/build.properties new file mode 100644 index 00000000000..36df47cc74a --- /dev/null +++ b/debug/org.eclipse.cdt.debug.ui.tests/build.properties @@ -0,0 +1 @@ +source.cdttests.jar = src/, ui/, core/, model/ diff --git a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/.cvsignore b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/.cvsignore new file mode 100644 index 00000000000..7d268d723cd --- /dev/null +++ b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/.cvsignore @@ -0,0 +1,3 @@ +WatchpointTests.java +LocationTests.java +TargetTests.java diff --git a/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/AllDebugTests.java b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/AllDebugTests.java new file mode 100644 index 00000000000..29895cf4142 --- /dev/null +++ b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/AllDebugTests.java @@ -0,0 +1,43 @@ +package org.eclipse.cdt.debug.core.tests; +/* + * (c) Copyright QNX Software Systems Ltd. 2002. + * All Rights Reserved. + */ + + + +import junit.framework.Test; +import junit.framework.TestSuite; + + +/** + * + * AllDedbugTests.java + * This is the main entry point for running this suite of JUnit tests + * for all tests within the package "org.eclipse.cdt.debug.core" + * + * @author Judy N. Green + * @since Jul 19, 2002 + */ +public class AllDebugTests { + + public static void main(String[] args) { + junit.textui.TestRunner.run(suite()); + } + + public static Test suite() { + TestSuite suite = new TestSuite(); + + // Just add more test cases here as you create them for + // each class being tested + + suite.addTest(DebugTests.suite()); + suite.addTest(BreakpointTests.suite()); + suite.addTest(LocationTests.suite()); + suite.addTest(TargetTests.suite()); + return suite; + + + } +} // End of AllDebugTests.java + 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 new file mode 100644 index 00000000000..11925668a1b --- /dev/null +++ b/debug/org.eclipse.cdt.debug.ui.tests/core/org/eclipse/cdt/debug/core/tests/BreakpointTests.java @@ -0,0 +1,615 @@ +package org.eclipse.cdt.debug.core.tests; + +/* + * (c) Copyright QNX Software Systems Ltd. 2002. + * All Rights Reserved. + */ + + +import java.io.FileNotFoundException; +import java.io.IOException; + +import junit.framework.TestCase; +import junit.framework.TestSuite; +import org.eclipse.cdt.debug.testplugin.*; +import org.eclipse.cdt.core.model.*; +import org.eclipse.core.resources.*; +import org.eclipse.core.runtime.*; +import org.eclipse.cdt.debug.mi.core.*; +import org.eclipse.cdt.debug.core.cdi.*; +import org.eclipse.cdt.debug.core.cdi.model.*; + +/** + * @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; + ICProject testProject; + NullProgressMonitor monitor; + + + /** + * 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 void setUp() throws CoreException,FileNotFoundException { + + /*** + * Setup the various files, paths and projects that are needed by the + * tests + */ + testProject=CProjectHelper.createCProject("filetest", "none"); + if (testProject==null) + fail("Unable to create project"); + } + + /** + * Tears down the test fixture. + * + * Called after every test case method. + */ + protected void tearDown() throws CoreException { + CProjectHelper.delete(testProject); + } + + public static TestSuite suite() { + return new TestSuite(BreakpointTests.class); + } + + public static void main (String[] args){ + junit.textui.TestRunner.run(suite()); + } + + + /*** + * 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; + ICDITarget targets[]; + boolean caught=false; + session=CDebugHelper.createSession("main"); + 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 */ + session.terminate(); + + + } + + /*** + * A couple tests to make sure setting breakpoints on line numbers works as + * expected. + */ + public void testLineBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException { + ICDISession session; + ICDIBreakpointManager breaks; + ICDILocation location; + ICDITarget targets[]; + boolean caught=false; + session=CDebugHelper.createSession("main"); + 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(); + + } + /*** + * A couple tests to make sure getting breakpoints works as expected + */ + public void testGetBreak() throws CoreException, MIException, IOException, CDIException { + ICDISession session; + ICDIBreakpointManager breaks; + ICDILocation location; + ICDIBreakpoint[] breakpoints; + ICDILocationBreakpoint curbreak; + session=CDebugHelper.createSession("main"); + 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(); + + + } + + /*** + * A couple tests to make sure deleting breakpoints works as expected + */ + public void testDelBreak() throws CoreException, MIException, IOException, CDIException { + ICDISession session; + ICDIBreakpointManager breaks; + ICDILocation location, savedLocation; + ICDIBreakpoint[] breakpoints, savedbreakpoints; + ICDILocationBreakpoint curbreak; + + session=CDebugHelper.createSession("main"); + 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); + /** + * 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); + + 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); + + 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); + + /* 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;xBootLoader which can be used to start
+ * up and run the platform. The given base, if not null,
+ * is the location of the boot loader code. If the value is null
+ * then the boot loader is located relative to this class.
+ *
+ * @return the new boot loader
+ * @param base the location of the boot loader
+ */
+public Class getBootLoader(String base) throws Exception {
+ URLClassLoader loader = new URLClassLoader(getBootPath(base), null);
+ return loader.loadClass(BOOTLOADER);
+}
+/**
+ * Returns the URL-based class path describing where the boot classes
+ * are located when running in development mode.
+ *
+ * @return the url-based class path
+ * @param base the base location
+ * @exception MalformedURLException if a problem occurs computing the class path
+ */
+protected URL[] getDevPath(URL base) throws MalformedURLException {
+ URL url;
+ String devBase = base.toExternalForm();
+ if (!inDevelopmentMode) {
+ url = new URL(devBase + "boot.jar");
+ return new URL[] {url};
+ }
+ String[] locations = getArrayFromList(devClassPath);
+ ArrayList result = new ArrayList(locations.length);
+ for (int i = 0; i < locations.length; i++) {
+ String spec = devBase + locations[i];
+ char lastChar = spec.charAt(spec.length() - 1);
+ if ((spec.endsWith(".jar") || (lastChar == '/' || lastChar == '\\')))
+ url = new URL (spec);
+ else
+ url = new URL(spec + "/");
+ //make sure URL exists before adding to path
+ if (new java.io.File(url.getFile()).exists())
+ result.add(url);
+ }
+ url = new URL(devBase + "boot.jar");
+ if (new java.io.File(url.getFile()).exists())
+ result.add(url);
+ return (URL[])result.toArray(new URL[result.size()]);
+}
+
+/**
+ * Returns the URL-based class path describing where the boot classes are located.
+ *
+ * @return the url-based class path
+ * @param base the base location
+ * @exception MalformedURLException if a problem occurs computing the class path
+ */
+protected URL[] getBootPath(String base) throws MalformedURLException {
+ URL url = null;
+ // if the given location is not null, assume it is correct and use it.
+ if (base != null) {
+ url = new URL(base);
+ if (debug)
+ System.out.println("Boot URL: " + url.toExternalForm());
+ return new URL[] {url};
+ }
+ // Create a URL based on the location of this class' code.
+ // strip off jar file and/or last directory to get
+ // to the directory containing projects.
+ URL[] result = null;
+ url = getClass().getProtectionDomain().getCodeSource().getLocation();
+ String path = url.getFile();
+ if (path.endsWith(".jar"))
+ path = path.substring(0, path.lastIndexOf("/"));
+ else
+ if (path.endsWith("/"))
+ path = path.substring(0, path.length() - 1);
+ if (inVAJ || inVAME) {
+ int ix = path.lastIndexOf("/");
+ path = path.substring(0, ix + 1);
+ path = path + PROJECT_NAME + "/";
+ url = new URL(url.getProtocol(), url.getHost(), url.getPort(), path);
+ result = new URL[] {url};
+ } else {
+ path = searchForPlugins(path);
+ path = searchForBoot(path);
+ // add on any dev path elements
+ url = new URL(url.getProtocol(), url.getHost(), url.getPort(), path);
+ result = getDevPath(url);
+ }
+ if (debug) {
+ System.out.println("Boot URL:");
+ for (int i = 0; i < result.length; i++)
+ System.out.println(" " + result[i].toExternalForm());
+ }
+ return result;
+}
+
+/**
+ * Searches for a plugins root starting at a given location. If one is
+ * found then this location is returned; otherwise an empty string is
+ * returned.
+ *
+ * @return the location where plugins were found, or an empty string
+ * @param start the location to begin searching at
+ */
+protected String searchForPlugins(String start) {
+ File path = new File(start);
+ while (path != null) {
+ File test = new File(path, "plugins");
+ if (test.exists())
+ return test.toString();
+ path = path.getParentFile();
+ path = (path == null || path.length() == 1) ? null : path;
+ }
+ return "";
+}
+/**
+ * Searches for a boot directory starting at a given location. If one
+ * is found then this location is returned; otherwise an empty string
+ * is returned.
+ *
+ * @return the location where plugins were found, or an empty string
+ * @param start the location to begin searching at
+ */
+protected String searchForBoot(String start) {
+ FileFilter filter = new FileFilter() {
+ public boolean accept(File candidate) {
+ return candidate.getName().startsWith(PI_BOOT);
+ }
+ };
+ File[] boots = new File(start).listFiles(filter);
+ String result = null;
+ String maxVersion = null;
+ for (int i = 0; i < boots.length; i++) {
+ String name = boots[i].getName();
+ int index = name.lastIndexOf('_');
+ if (index == -1) {
+ result = boots[i].getAbsolutePath();
+ i = boots.length;
+ } else {
+ if (index > 0) {
+ String version = name.substring(index + 1);
+ if (maxVersion == null) {
+ result = boots[i].getAbsolutePath();
+ maxVersion = version;
+ } else
+ if (maxVersion.compareTo(version) == -1) {
+ result = boots[i].getAbsolutePath();
+ maxVersion = version;
+ }
+ }
+ }
+ }
+ if (result == null)
+ throw new RuntimeException("Could not find bootstrap code. Check location of boot plug-in or specify -boot.");
+ return result.replace(File.separatorChar, '/') + "/";
+}
+/**
+ * Returns the update loader for the given boot path.
+ *
+ * @return the update loader
+ * @param base the boot path base
+ * @exception Exception thrown is a problem occurs determining this loader
+ */
+public Class getUpdateLoader(String base) throws Exception {
+ URLClassLoader loader = new URLClassLoader(getBootPath(base), null);
+ return loader.loadClass(UPDATELOADER);
+}
+/**
+ * Runs the platform with the given arguments. The arguments must identify
+ * an application to run (e.g., -application com.example.application).
+ * After running the application System.exit(N) is executed.
+ * The value of N is derived from the value returned from running the application.
+ * If the application's return value is an Integer, N is this value.
+ * In all other cases, N = 0.
+ *
+ * Clients wishing to run the platform without a following System.exit
+ * call should use run().
+ *
+ * @see #run
+ *
+ * @param args the command line arguments
+ */
+public static void main(String[] args) {
+ Object result = null;
+ try {
+ result = new Main().run(args);
+ } catch (Throwable e) {
+ // try and take down the splash screen.
+ endSplash();
+ System.out.println("Exception launching the Eclipse Platform:");
+ e.printStackTrace();
+ }
+ int exitCode = result instanceof Integer ? ((Integer) result).intValue() : 0;
+ System.exit(exitCode);
+}
+/**
+ * Tears down the currently-displayed splash screen.
+ */
+public static void endSplash() {
+ if (endSplash == null)
+ return;
+ try {
+ Runtime.getRuntime().exec(endSplash);
+ } catch (Exception e) {
+ }
+}
+
+/**
+ * Runs this launcher with the arguments specified in the given string.
+ *
+ * @param argString the arguments string
+ * @exception Exception thrown if a problem occurs during launching
+ */
+public static void main(String argString) throws Exception {
+ Vector list = new Vector(5);
+ for (StringTokenizer tokens = new StringTokenizer(argString, " "); tokens.hasMoreElements();)
+ list.addElement((String) tokens.nextElement());
+ main((String[]) list.toArray(new String[list.size()]));
+}
+
+/**
+ * Processes the command line arguments
+ *
+ * @return the arguments to pass through to the launched application
+ * @param args the command line arguments
+ */
+protected String[] processCommandLine(String[] args) throws Exception {
+ int[] configArgs = new int[100];
+ configArgs[0] = -1; // need to initialize the first element to something that could not be an index.
+ int configArgIndex = 0;
+ for (int i = 0; i < args.length; i++) {
+ boolean found = false;
+ // check for args without parameters (i.e., a flag arg)
+ // check if debug should be enabled for the entire platform
+ if (args[i].equalsIgnoreCase(DEBUG)) {
+ debug = true;
+ // passed thru this arg (i.e., do not set found = true
+ continue;
+ }
+
+ // check if development mode should be enabled for the entire platform
+ // If this is the last arg or there is a following arg (i.e., arg+1 has a leading -),
+ // simply enable development mode. Otherwise, assume that that the following arg is
+ // actually some additional development time class path entries. This will be processed below.
+ if (args[i].equalsIgnoreCase(DEV) && ((i + 1 == args.length) || ((i + 1 < args.length) && (args[i + 1].startsWith("-"))))) {
+ inDevelopmentMode = true;
+ // do not mark the arg as found so it will be passed through
+ continue;
+ }
+
+ // done checking for args. Remember where an arg was found
+ if (found) {
+ configArgs[configArgIndex++] = i;
+ continue;
+ }
+ // check for args with parameters. If we are at the last argument or if the next one
+ // has a '-' as the first character, then we can't have an arg with a parm so continue.
+ if (i == args.length - 1 || args[i + 1].startsWith("-"))
+ continue;
+ String arg = args[++i];
+
+ // look for the laucher to run
+ if (args[i - 1].equalsIgnoreCase(BOOT)) {
+ bootLocation = arg;
+ found = true;
+ }
+
+ // look for the development mode and class path entries.
+ if (args[i - 1].equalsIgnoreCase(DEV)) {
+ inDevelopmentMode = true;
+ devClassPath = arg;
+ continue;
+ }
+
+ // look for the application to run
+ if (args[i - 1].equalsIgnoreCase(APPLICATION)) {
+ application = arg;
+ found = true;
+ }
+
+ // look for token to use to end the splash screen
+ if (args[i - 1].equalsIgnoreCase(ENDSPLASH)) {
+ endSplash = arg;
+ continue;
+ }
+
+ // look for items to uninstall
+ if (args[i - 1].equalsIgnoreCase(UNINSTALL)) {
+ uninstall = true;
+ uninstallCookie = arg;
+ found = true;
+ }
+
+ // done checking for args. Remember where an arg was found
+ if (found) {
+ configArgs[configArgIndex++] = i - 1;
+ configArgs[configArgIndex++] = i;
+ }
+ }
+ // remove all the arguments consumed by this argument parsing
+ if (configArgIndex == 0)
+ return args;
+ String[] passThruArgs = new String[args.length - configArgIndex];
+ configArgIndex = 0;
+ int j = 0;
+ for (int i = 0; i < args.length; i++) {
+ if (i == configArgs[configArgIndex])
+ configArgIndex++;
+ else
+ passThruArgs[j++] = args[i];
+ }
+ return passThruArgs;
+}
+/**
+ * Runs the application to be launched.
+ *
+ * @return the return value from the launched application
+ * @param args the arguments to pass to the application
+ * @exception thrown if a problem occurs during launching
+ */
+public Object run(String[] args) throws Exception {
+ String[] passThruArgs = processCommandLine(args);
+ if (uninstall)
+ return updateRun(UNINSTALL, uninstallCookie, passThruArgs);
+ else
+ return basicRun(passThruArgs);
+}
+/**
+ * Performs an update run.
+ *
+ * @return the return value from the update loader
+ * @param flag flag to give to the update loader
+ * @param value value to give to the update loader
+ * @param args arguments to give to the update loader.
+ * @exception Exception thrown if a problem occurs during execution
+ */
+protected Object updateRun(String flag, String value, String[] args) throws Exception {
+ Class clazz = getUpdateLoader(bootLocation);
+ Method method = clazz.getDeclaredMethod("run", new Class[] { String.class, String.class, String.class, String[].class });
+ try {
+ return method.invoke(clazz, new Object[] { flag, value, location, args });
+ } catch (InvocationTargetException e) {
+ if (e.getTargetException() instanceof Error)
+ throw (Error) e.getTargetException();
+ else
+ throw e;
+ }
+}
+}
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/NewMain.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/NewMain.java
new file mode 100644
index 00000000000..db442c80e60
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/NewMain.java
@@ -0,0 +1,73 @@
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+package org.eclipse.cdt.debug.testplugin;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Properties;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+/**
+ * Application is responsible for calling core launch api
+ */
+
+public class NewMain extends Main {
+ private static final String DEFAULT_APPLICATION= "org.eclipse.ui.workbench";
+
+
+ public NewMain(String application, String location, URL pluginPathLocation, String bootLocation, boolean debug) throws IOException {
+ this.application= application;
+ this.location= location;
+ this.pluginPathLocation= pluginPathLocation;
+ this.bootLocation= bootLocation;
+ }
+
+ public static void main(String[] args) {
+ try {
+ String location= getLocationFromProperties("platform");
+ new NewMain(DEFAULT_APPLICATION, location, null, null, true).run(args);
+ } catch (Throwable e) {
+ System.out.println("Exception launching the Eclipse Platform UI:");
+ e.printStackTrace();
+ }
+ System.exit(0);
+ }
+
+
+ /**
+ * Run this launcher with the arguments specified in the given string.
+ * This is a short cut method for people running the launcher from
+ * a scrapbook (i.e., swip-and-doit facility).
+ */
+ public static void main(String argString) throws Exception {
+ Vector list= new Vector(5);
+ for (StringTokenizer tokens= new StringTokenizer(argString, " "); tokens.hasMoreElements();)
+ list.addElement((String) tokens.nextElement());
+ main((String[]) list.toArray(new String[list.size()]));
+ }
+
+ public static String getLocationFromProperties(String key) {
+ Properties properties= new Properties();
+ try {
+ FileInputStream fis= new FileInputStream(getSettingsFile());
+ properties.load(fis);
+ return properties.getProperty(key);
+ } catch (IOException e) {
+ }
+ return null;
+ }
+
+ private static File getSettingsFile() {
+ String home= System.getProperty("user.home");
+ if (home == null) {
+ System.out.println("Home dir not defined");
+ return null;
+ }
+ return new File(home, "eclipse-workspaces.properties");
+ }
+}
\ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/TestPluginLauncher.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/TestPluginLauncher.java
new file mode 100644
index 00000000000..ce3e74013d1
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/TestPluginLauncher.java
@@ -0,0 +1,57 @@
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+package org.eclipse.cdt.debug.testplugin;
+
+import java.net.URL;
+
+/**
+ * Helper class to launch a test
+ */
+public class TestPluginLauncher {
+
+ public static final String APP_NAME= "org.eclipse.jdt.ui.tests.app";
+
+ public static void run(String location, Class testCase, String[] args) {
+ run(APP_NAME, location, testCase, args);
+ }
+
+ public static void run(String application, String location, Class testCase, String[] args) {
+ try {
+ String bootLocation= getBootLocation();
+ int nArgs= args.length;
+ String[] newArgs= new String[4 + nArgs];
+ newArgs[0]= testCase.getName();
+ for (int i= 0; i < nArgs; i++) {
+ newArgs[1 + i]= args[i];
+ }
+ newArgs[1 + nArgs]= "-dev";
+ newArgs[1 + nArgs + 1]= "bin";
+ newArgs[1 + nArgs + 2]= "-debug";
+ NewMain newMain= new NewMain(application, location, null, bootLocation, false);
+ newMain.run(newArgs);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static String getLocationFromProperties(String key) {
+ return NewMain.getLocationFromProperties(key);
+ }
+
+ public static String getLocationFromProperties() {
+ return NewMain.getLocationFromProperties("tests");
+ }
+
+ public static String getBootLocation() {
+ URL url= TestPluginLauncher.class.getResource("TestPluginLauncher.class");
+ String s= url.toString();
+ int index= s.indexOf("/org.eclipse.jdt.ui.tests");
+ if (index == -1)
+ throw new IllegalArgumentException();
+ s= s.substring(0, index);
+ s= s + "/org.eclipse.core.boot/boot.jar";
+ return s;
+ }
+}
\ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/TestWorkbench.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/TestWorkbench.java
new file mode 100644
index 00000000000..e5da8ce0c43
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/TestWorkbench.java
@@ -0,0 +1,79 @@
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+package org.eclipse.cdt.debug.testplugin;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import junit.textui.TestRunner;
+
+import org.eclipse.core.runtime.IPath;
+
+import org.eclipse.swt.widgets.Display;
+
+import org.eclipse.ui.internal.Workbench;
+
+public class TestWorkbench extends Workbench {
+
+ /**
+ * Run an event loop for the workbench.
+ */
+ protected void runEventLoop() {
+ // Dispatch all events.
+ Display display = Display.getCurrent();
+ while (true) {
+ try {
+ if (!display.readAndDispatch())
+ break;
+ } catch (Throwable e) {
+ break;
+ }
+ }
+ IPath location= CTestPlugin.getDefault().getWorkspace().getRoot().getLocation();
+ System.out.println("Workspace-location: " + location.toString());
+
+
+ try {
+ String[] args= getCommandLineArgs();
+ if (args.length > 0) {
+ Test test= getTest(args[0]);
+ TestRunner.run(test);
+ } else {
+ System.out.println("TestWorkbench: Argument must be class name");
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+
+ // Close the workbench.
+ close();
+ }
+
+ public Test getTest(String className) throws Exception {
+ Class testClass= getClass().getClassLoader().loadClass(className);
+
+ Method suiteMethod= null;
+ try {
+ suiteMethod= testClass.getMethod(TestRunner.SUITE_METHODNAME, new Class[0]);
+ } catch (Exception e) {
+ // try to extract a test suite automatically
+ return new TestSuite(testClass);
+ }
+ try {
+ return (Test) suiteMethod.invoke(null, new Class[0]); // static method
+ } catch (InvocationTargetException e) {
+ System.out.println("Failed to invoke suite():" + e.getTargetException().toString());
+ } catch (IllegalAccessException e) {
+ System.out.println("Failed to invoke suite():" + e.toString());
+ }
+ return null;
+
+ }
+
+
+}
\ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/test/HelloWorld.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/test/HelloWorld.java
new file mode 100644
index 00000000000..1e9a2f05689
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/test/HelloWorld.java
@@ -0,0 +1,49 @@
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+package org.eclipse.cdt.debug.testplugin.test;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.eclipse.cdt.core.model.ICProject;
+import org.eclipse.cdt.debug.testplugin.CProjectHelper;
+import org.eclipse.cdt.debug.testplugin.TestPluginLauncher;
+
+
+public class HelloWorld extends TestCase {
+
+ private ICProject fCProject;
+
+ public static void main(String[] args) {
+ TestPluginLauncher.run(TestPluginLauncher.getLocationFromProperties(), HelloWorld.class, args);
+ }
+
+ public static Test suite() {
+ TestSuite suite= new TestSuite();
+ suite.addTest(new HelloWorld("test1"));
+ return suite;
+ }
+
+ public HelloWorld(String name) {
+ super(name);
+ }
+
+ protected void setUp() throws Exception {
+ fCProject= CProjectHelper.createCProject("TestProject1", "bin");
+ }
+
+
+ protected void tearDown() throws Exception {
+ CProjectHelper.delete(fCProject);
+ }
+
+ public void test1() throws Exception {
+
+ assertTrue("Exception to test", 0 != 0);
+
+ }
+
+}
\ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/AccessibilityTestPass.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/AccessibilityTestPass.java
new file mode 100644
index 00000000000..8bf67a4ad3a
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/AccessibilityTestPass.java
@@ -0,0 +1,66 @@
+package org.eclipse.cdt.debug.testplugin.util;
+
+
+import java.util.ArrayList;
+
+
+public class AccessibilityTestPass implements IDialogTestPass {
+ private static final int CHECKLIST_SIZE = 5;
+
+ /**
+ * @see IDialogTestPass#title()
+ */
+ public String title() {
+ return "Test Pass: Accessibility";
+ }
+ /**
+ * @see IDialogTestPass#description()
+ */
+ public String description() {
+ return "Verify the accessibility of the dialogs.";
+ }
+ /**
+ * @see IDialogTestPass#label()
+ */
+ public String label() {
+ return "&Accessibility";
+ }
+ /**
+ * @see IDialogTestPass#checkListTexts()
+ */
+ public ArrayList checkListTexts() {
+ ArrayList list = new ArrayList(CHECKLIST_SIZE);
+ list.add("&1) all widgets are accessible by tabbing.");
+ list.add("&2) forwards and backwards tabbing is in a logical order");
+ list.add("&3) all the widgets with labels have an appropriate mnemonic.");
+ list.add("&4) there are no duplicate mnemonics.");
+ list.add("&5) selectable widgets can be selected using the spacebar.");
+ return list;
+ }
+ /**
+ * @see IDialogTestPass#failureTexts()
+ * Size of the return array must be the same size as the checkListTexts'
+ * ArrayList.
+ */
+ public String[] failureTexts() {
+ String[] failureText = new String[CHECKLIST_SIZE];
+ failureText[0] = "Some widgets aren't accessible by tabbing.";
+ failureText[1] = "Tabbing order is illogical.";
+ failureText[2] = "Missing or inappropriate mnemonics.";
+ failureText[3] = "Duplicate mnemonics.";
+ failureText[4] = "Some widgets cannot be selected using the spacebar.";
+ return failureText;
+ }
+ /**
+ * @see IDialogTestPass#queryText()
+ */
+ public String queryText() {
+ return "Is the accessibility of the dialog acceptable?";
+ }
+ /**
+ * @see IDialogTestPass#getID()
+ */
+ public int getID() {
+ return VerifyDialog.TEST_ACCESS;
+ }
+}
\ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/DialogCheck.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/DialogCheck.java
new file mode 100644
index 00000000000..2fd5792c78e
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/DialogCheck.java
@@ -0,0 +1,225 @@
+package org.eclipse.cdt.debug.testplugin.util;
+
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+
+import junit.framework.Assert;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Shell;
+
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.IDialogConstants;
+
+import org.eclipse.ui.internal.WorkbenchPlugin;
+
+
+/**
+ * A DialogCheck is used test a dialog in
+ * various ways.
+ *
+ * For interactive tests use assertDialog.
+ * For automated tests use assert DialogTexts.
+ *
Dialog dialog = new AboutDialog( DialogCheck.getShell() );
+ * DialogCheck.assertDialog(dialog, this);
+ *
+ * @param dialog the test dialog to be verified.
+ * @param assert this is the test case object, assertions will be
+ * executed on this object.
+ */
+ public static void assertDialog(Dialog dialog, Assert assert) {
+ assert.assertNotNull(dialog);
+ if (_verifyDialog.getShell() == null) {
+ //force the creation of the verify dialog
+ getShell();
+ }
+ if (_verifyDialog.open(dialog) == IDialogConstants.NO_ID) {
+ assert.assertTrue(_verifyDialog.getFailureText(), false);
+ }
+ }
+
+
+ /**
+ * Automated test that checks all the labels and buttons of a dialog
+ * to make sure there is enough room to display all the text. Any
+ * text that wraps is only approximated and is currently not accurate.
+ *
+ * @param dialog the test dialog to be verified.
+ * @param assert this is the test case object, assertions will be
+ * executed on this object.
+ */
+ public static void assertDialogTexts(Dialog dialog, Assert assert) {
+ assert.assertNotNull(dialog);
+ dialog.setBlockOnOpen(false);
+ dialog.open();
+ Shell shell = dialog.getShell();
+ verifyCompositeText(shell, assert);
+ dialog.close();
+ }
+
+
+ /**
+ * This method should be called when creating dialogs to test. This
+ * ensures that the dialog's parent shell will be that of the
+ * verification dialog.
+ *
+ * @return Shell The shell of the verification dialog to be used as
+ * the parent shell of the test dialog.
+ */
+ public static Shell getShell() {
+ Shell shell =
+ WorkbenchPlugin
+ .getDefault()
+ .getWorkbench()
+ .getActiveWorkbenchWindow()
+ .getShell();
+ _verifyDialog = new VerifyDialog(shell);
+ _verifyDialog.create();
+ return _verifyDialog.getShell();
+ }
+
+
+ /*
+ * Looks at all the child widgets of a given composite and
+ * verifies the text on all labels and widgets.
+ * @param composite The composite to look through
+ * @param assert The object to invoke assertions on.
+ */
+ private static void verifyCompositeText(Composite composite, Assert assert) {
+ Control children[] = composite.getChildren();
+ for (int i = 0; i < children.length; i++) {
+ try {
+ //verify the text if the child is a button
+ verifyButtonText((Button) children[i], assert);
+ } catch (ClassCastException exNotButton) {
+ try {
+ //child is not a button, maybe a label
+ verifyLabelText((Label) children[i], assert);
+ } catch (ClassCastException exNotLabel) {
+ try {
+ //child is not a label, make a recursive call if it is a composite
+ verifyCompositeText((Composite) children[i], assert);
+ } catch (ClassCastException exNotComposite) {
+ //the child is not a button, label, or composite - ignore it.
+ }
+ }
+ }
+ }
+ }
+
+ /*
+ * Verifies that a given button is large enough to display its text.
+ * @param button The button to verify,
+ * @param assert The object to invoke assertions on.
+ */
+ private static void verifyButtonText(Button button, Assert assert) {
+ String widget = button.toString();
+ Point size = button.getSize();
+
+
+ //compute the size with no line wrapping
+ Point preferred = button.computeSize(SWT.DEFAULT, SWT.DEFAULT);
+ //if (size.y/preferred.y) == X, then label spans X lines, so divide
+ //the calculated value of preferred.x by X
+ if (preferred.y * size.y > 0) {
+ preferred.y /= countLines(button.getText()); //check for '\n\'
+ if (size.y / preferred.y > 1) {
+ preferred.x /= (size.y / preferred.y);
+ }
+ }
+
+
+ String message =
+ new StringBuffer("Warning: ")
+ .append(widget)
+ .append("\n\tActual Width -> ")
+ .append(size.x)
+ .append("\n\tRecommended Width -> ")
+ .append(preferred.x)
+ .toString();
+ if (preferred.x > size.x) {
+ //close the dialog
+ button.getShell().dispose();
+ assert.assertTrue(message.toString(), false);
+ }
+ }
+
+ /*
+ * Verifies that a given label is large enough to display its text.
+ * @param label The label to verify,
+ * @param assert The object to invoke assertions on.
+ */
+ private static void verifyLabelText(Label label, Assert assert) {
+ String widget = label.toString();
+ Point size = label.getSize();
+
+
+ //compute the size with no line wrapping
+ Point preferred = label.computeSize(SWT.DEFAULT, SWT.DEFAULT);
+ //if (size.y/preferred.y) == X, then label spans X lines, so divide
+ //the calculated value of preferred.x by X
+ if (preferred.y * size.y > 0) {
+ preferred.y /= countLines(label.getText());
+ if (size.y / preferred.y > 1) {
+ preferred.x /= (size.y / preferred.y);
+ }
+ }
+ String message =
+ new StringBuffer("Warning: ")
+ .append(widget)
+ .append("\n\tActual Width -> ")
+ .append(size.x)
+ .append("\n\tRecommended Width -> ")
+ .append(preferred.x)
+ .toString();
+ if (preferred.x > size.x) {
+ //close the dialog
+ label.getShell().dispose();
+ assert.assertTrue(message.toString(), false);
+ }
+ }
+
+ /*
+ * Counts the number of lines in a given String.
+ * For example, if a string contains one (1) newline character,
+ * a value of two (2) would be returned.
+ * @param text The string to look through.
+ * @return int the number of lines in text.
+ */
+ private static int countLines(String text) {
+ int newLines = 1;
+ for (int i = 0; i < text.length(); i++) {
+ if (text.charAt(i) == '\n') {
+ newLines++;
+ }
+ }
+ return newLines;
+ }
+}
\ No newline at end of file
diff --git a/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/ExpectedStrings.java b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/ExpectedStrings.java
new file mode 100644
index 00000000000..e79254f0211
--- /dev/null
+++ b/debug/org.eclipse.cdt.debug.ui.tests/src/org/eclipse/cdt/debug/testplugin/util/ExpectedStrings.java
@@ -0,0 +1,96 @@
+package org.eclipse.cdt.debug.testplugin.util;
+
+
+import java.util.Stack;
+/**
+ * @author Peter Graves
+ *
+ * This utility class maintains a list of strings, and as a tests finds strings
+ * in a structure/list, it will maintain a list of unfound/extra strings.
+ */
+public class ExpectedStrings {
+
+ public String [] expStrings;
+ private boolean[] foundStrings;
+ private Stack extraStrings; /* A stack of the unecpected strings we
+ * recieved
+ */
+ private boolean extra;
+
+ /**
+ * Constructor for ExpectedStrings.
+ */
+ public ExpectedStrings() {
+ }
+ /**
+ * Constructor for ExpectedStrings that accepts a list of strings that
+ * we expect to get.
+ */
+ public ExpectedStrings(String[] values) {
+ int x;
+ expStrings=new String[values.length];
+ for (x=0;x