diff options
author | Sebastien Marineau | 2002-08-20 16:35:24 +0000 |
---|---|---|
committer | Sebastien Marineau | 2002-08-20 16:35:24 +0000 |
commit | 612877ef1de384f2214fb1e09e42a04ed762ee99 (patch) | |
tree | 694d68c2e400a6df45c8f59c7aa0c1486005a11d /core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin | |
parent | 734efafff7c562f05121ba0bba0a780504ed466e (diff) | |
download | org.eclipse.cdt-612877ef1de384f2214fb1e09e42a04ed762ee99.tar.gz org.eclipse.cdt-612877ef1de384f2214fb1e09e42a04ed762ee99.tar.xz org.eclipse.cdt-612877ef1de384f2214fb1e09e42a04ed762ee99.zip |
First crack at junit CDT tests
Diffstat (limited to 'core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin')
16 files changed, 1999 insertions, 0 deletions
diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CElementDecorator.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CElementDecorator.java new file mode 100644 index 00000000000..b6b239f11a9 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CElementDecorator.java @@ -0,0 +1,30 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.testplugin; + +import org.eclipse.swt.graphics.Image; + +import org.eclipse.jface.viewers.ILabelDecorator; +import org.eclipse.jface.viewers.LabelProvider; + +/** + * Allows to test decorators for Java elements + */ +public class CElementDecorator extends LabelProvider implements ILabelDecorator { + + /* + * @see ILabelDecorator#decorateImage(Image, Object) + */ + public Image decorateImage(Image image, Object element) { + return null; + } + + /* + * @see ILabelDecorator#decorateText(String, Object) + */ + public String decorateText(String text, Object element) { + return text + "*"; + } +} diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CProjectHelper.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CProjectHelper.java new file mode 100644 index 00000000000..02e0051ab9f --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CProjectHelper.java @@ -0,0 +1,196 @@ +package org.eclipse.cdt.testplugin; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.zip.ZipFile; + +import org.eclipse.cdt.core.CCorePlugin; +import org.eclipse.cdt.core.CProjectNature; +import org.eclipse.cdt.core.model.CModelException; +import org.eclipse.cdt.core.model.ICFolder; +import org.eclipse.cdt.core.model.ICProject; +import org.eclipse.cdt.internal.core.model.CModelManager; +import org.eclipse.core.resources.IContainer; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IFolder; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IProjectDescription; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.Path; +import org.eclipse.ui.dialogs.IOverwriteQuery; +import org.eclipse.ui.wizards.datatransfer.ImportOperation; +import org.eclipse.ui.wizards.datatransfer.ZipFileStructureProvider; + +/** + * Helper methods to set up a IJavaProject. + */ +public class CProjectHelper { + + public static final IPath RT_STUBS= new Path("testresources/rtstubs.jar"); + public static final IPath JUNIT_SRC= new Path("testresources/junit37-noUI-src.zip"); + + public static final IPath MYLIB= new Path("testresources/mylib.jar"); + + + /** + * Creates a ICProject. + */ + public static ICProject createCProject(String projectName, String binFolderName) throws CoreException { + IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot(); + IProject project= root.getProject(projectName); + if (!project.exists()) { + project.create(null); + } else { + project.refreshLocal(IResource.DEPTH_INFINITE, null); + } + + if (!project.isOpen()) { + project.open(null); + } + + + if (!project.hasNature(CProjectNature.C_NATURE_ID)) { + addNatureToProject(project, CProjectNature.C_NATURE_ID, null); + } + + ICProject cproject = CCorePlugin.getDefault().getCoreModel().create(project); + + return cproject; + } + + /** + * Removes a ICProject. + */ + public static void delete(ICProject cproject) throws CoreException { + performDummySearch(); + cproject.getProject().delete(true, true, null); + } + + public static void performDummySearch() throws CModelException { + /* SearchEngine().searchAllTypeNames( + ResourcesPlugin.getWorkspace(), + null, + null, + IJavaSearchConstants.EXACT_MATCH, + IJavaSearchConstants.CASE_SENSITIVE, + IJavaSearchConstants.CLASS, + SearchEngine.createJavaSearchScope(new IJavaElement[0]), + new Requestor(), + IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH, + null); */ + } + + + /** + * Adds a source container to a ICProject. + */ + public static ICFolder addSourceContainer(ICProject cproject, String containerName) throws CoreException { + IProject project= cproject.getProject(); + IContainer container= null; + if (containerName == null || containerName.length() == 0) { + container= project; + } else { + IFolder folder= project.getFolder(containerName); + if (!folder.exists()) { + folder.create(false, true, null); + } + container= folder; + } + + return (ICFolder)container; + } + + /** + * Adds a source container to a ICProject and imports all files contained + * in the given Zip file. + */ + public static ICFolder addSourceContainerWithImport(ICProject cproject, String containerName, ZipFile zipFile) throws InvocationTargetException, CoreException { + ICFolder root= addSourceContainer(cproject, containerName); + importFilesFromZip(zipFile, root.getPath(), null); + return root; + } + + /** + * Removes a source folder from a IJavaProject. + */ + public static void removeSourceContainer(ICProject cproject, String containerName) throws CoreException { + IFolder folder= cproject.getProject().getFolder(containerName); + folder.delete(true, null); + } + + + /** + * Adds a required project entry. + */ + public static void addRequiredProject(ICProject cproject, ICProject required) throws CModelException { + //IClasspathEntry cpe= JavaCore.newProjectEntry(required.getProject().getFullPath()); + //addToClasspath(cproject, cpe); + } + + + /** + * Try to find rt.jar + */ + public static IPath[] findRtJar() { + File rtStubs= CTestPlugin.getDefault().getFileInPlugin(RT_STUBS); + if (rtStubs != null && rtStubs.exists()) { + return new IPath[] { + new Path(rtStubs.getPath()), + null, + null + }; + } + + /* + IVMInstall vmInstall= JavaRuntime.getDefaultVMInstall(); + if (vmInstall != null) { + LibraryLocation loc= vmInstall.getVMInstallType().getDefaultLibraryLocation(vmInstall.getInstallLocation()); + if (loc != null) { + return new IPath[] { + new Path(loc.getSystemLibrary().getPath()), + new Path(loc.getSystemLibrarySource().getPath()), + loc.getPackageRootPath() + }; + } + }*/ + return null; + } + + private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException { + IProjectDescription description = proj.getDescription(); + String[] prevNatures= description.getNatureIds(); + String[] newNatures= new String[prevNatures.length + 1]; + System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length); + newNatures[prevNatures.length]= natureId; + description.setNatureIds(newNatures); + proj.setDescription(description, monitor); + } + + private static void importFilesFromZip(ZipFile srcZipFile, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException { + ZipFileStructureProvider structureProvider= new ZipFileStructureProvider(srcZipFile); + try { + ImportOperation op= new ImportOperation(destPath, structureProvider.getRoot(), structureProvider, new ImportOverwriteQuery()); + op.run(monitor); + } catch (InterruptedException e) { + // should not happen + } + } + + private static class ImportOverwriteQuery implements IOverwriteQuery { + public String queryOverwrite(String file) { + return ALL; + } + } + + +} + diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CTestPlugin.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CTestPlugin.java new file mode 100644 index 00000000000..3fb21c036fb --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CTestPlugin.java @@ -0,0 +1,58 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.testplugin; + +import java.io.File; +import java.io.IOException; +import java.net.URL; + +import org.eclipse.core.resources.IWorkspace; +import org.eclipse.core.resources.IWorkspaceDescription; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IPluginDescriptor; +import org.eclipse.core.runtime.Platform; +import org.eclipse.core.runtime.Plugin; + + +public class CTestPlugin extends Plugin { + + private static CTestPlugin fgDefault; + + public CTestPlugin(IPluginDescriptor descriptor) { + super(descriptor); + fgDefault= this; + } + + public static CTestPlugin getDefault() { + return fgDefault; + } + + public static IWorkspace getWorkspace() { + return ResourcesPlugin.getWorkspace(); + } + + public static void enableAutobuild(boolean enable) throws CoreException { + // disable auto build + IWorkspace workspace= fgDefault.getWorkspace(); + IWorkspaceDescription desc= workspace.getDescription(); + desc.setAutoBuilding(enable); + workspace.setDescription(desc); + } + + public File getFileInPlugin(IPath path) { + try { + URL installURL= new URL(getDescriptor().getInstallURL(), path.toString()); + URL localURL= Platform.asLocalURL(installURL); + return new File(localURL.getFile()); + } catch (IOException e) { + return null; + } + } + + + +}
\ No newline at end of file diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CTestSetup.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CTestSetup.java new file mode 100644 index 00000000000..3e143d5a048 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/CTestSetup.java @@ -0,0 +1,32 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.testplugin; + +import junit.extensions.TestSetup; +import junit.framework.Test; + +import org.eclipse.core.resources.IWorkspaceRoot; + + +public class CTestSetup extends TestSetup { + + /** + * @deprecated + * Not needed anymore. No added value + */ + public CTestSetup(Test test) { + super(test); + } + + protected void setUp() throws Exception { + } + + protected void tearDown() throws Exception { + } + + + + +}
\ No newline at end of file diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/Main.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/Main.java new file mode 100644 index 00000000000..a6d6af47ca0 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/Main.java @@ -0,0 +1,528 @@ +package org.eclipse.cdt.testplugin; + +// copied from startup.jar. planned to be removed soon + + +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ + +import java.net.*; +import java.lang.reflect.*; +import java.io.*; +import java.util.*; +/** + * Startup class for Eclipse. Creates a class loader using + * supplied URL of platform installation, loads and calls + * the Eclipse Boot Loader. The startup arguments are as follows: + * <dl> + * <dd> + * -application <id>: the identifier of the application to run + * </dd> + * <dd> + * -boot <location>: the location, expressed as a URL, of the platform's boot.jar + * </dd> + * <dd> + * -consolelog : enables log to the console. Handy when combined with -debug + * </dd> + * <dd> + * -data <location>: sets the workspace location and the default location for projects + * </dd> + * <dd> + * -debug [options file]: turns on debug mode for the platform and optionally specifies a location + * for the .options file. This file indicates what debug points are available for a + * plug-in and whether or not they are enabled. If a location is not specified, the platform searches + * for the .options file under the install directory + * </dd> + * <dd> + * -dev [entries]: turns on dev mode and optionally specifies comma-separated class path entries + * which are added to the class path of each plug-in + * </dd> + * <dd> + * -keyring <location>: the location of the authorization database on disk. This argument + * has to be used together with the -password argument + * </dd> + * <dd> + * -password <passwd>: the password for the authorization database + * </dd> + * <dd> + * -plugins <location>: The arg is a URL pointing to a file which specs the plugin + * path for the platform. The file is in property file format where the keys are user-defined + * names and the values are comma separated lists of either explicit paths to plugin.xml + * files or directories containing plugins. (e.g., .../eclipse/plugins). + * </dd> + * <dd> + * -ws <window system>: sets the window system value + * </dd> + * </dl> + */ +public class Main { + /** + * Indicates whether this instance is running in debug mode. + */ + protected boolean debug = false; + + /** + * The location of the launcher to run. + */ + protected String bootLocation = null; + + /** + * The identifier of the application to run. + */ + protected String application; + + /** + * The path for finding find plugins. + */ + protected URL pluginPathLocation; + + /** + * The boot path location. + */ + protected String location; + + /** + * Indicates whether items for UNinstallation should be looked for. + */ + protected boolean uninstall = false; + + /** + * The item to be uninstalled. + */ + protected String uninstallCookie; + + /** + * The class path entries. + */ + protected String devClassPath = null; + + /** + * Indicates whether this instance is running in development mode. + */ + protected boolean inDevelopmentMode = false; + + // static token describing how to take down the splash screen + private static String endSplash = null; + + // constants + private static final String APPLICATION = "-application"; + private static final String BOOT = "-boot"; + private static final String DEBUG = "-debug"; + private static final String DEV = "-dev"; + private static final String ENDSPLASH = "-endsplash"; + private static final String UNINSTALL = "-uninstall"; + private static final String PI_BOOT = "org.eclipse.core.boot"; + private static final String BOOTLOADER = "org.eclipse.core.boot.BootLoader"; + private static final String UPDATELOADER = "org.eclipse.core.internal.boot.LaunchInfo"; + + // The project containing the boot loader code. This is used to construct + // the correct class path for running in VAJ and VAME. + private static final String PROJECT_NAME = "Eclipse Core Boot"; + + private static boolean inVAJ; + static { + try { + Class.forName("com.ibm.uvm.lang.ProjectClassLoader"); + inVAJ = true; + } catch (Exception e) { + inVAJ = false; + } + } + private static boolean inVAME; + static { + try { + Class.forName("com.ibm.eclipse.core.VAME"); + inVAME = true; + } catch (Exception e) { + inVAME = false; + } + } + +/** + * Executes the launch. + * + * @return the result of performing the launch + * @param args command-line arguments + * @exception Exception thrown if a problem occurs during the launch + */ +protected Object basicRun(String[] args) throws Exception { + Class clazz = getBootLoader(bootLocation); + Method method = clazz.getDeclaredMethod("run", new Class[] { String.class, URL.class, String.class, String[].class }); + try { + return method.invoke(clazz, new Object[] { application, pluginPathLocation, location, args }); + } catch (InvocationTargetException e) { + if (e.getTargetException() instanceof Error) + throw (Error) e.getTargetException(); + else + throw e; + } +} + +/** + * Returns the result of converting a list of comma-separated tokens into an array + * + * @return the array of string tokens + * @param prop the initial comma-separated string + */ +private String[] getArrayFromList(String prop) { + if (prop == null || prop.trim().equals("")) + return new String[0]; + Vector list = new Vector(); + StringTokenizer tokens = new StringTokenizer(prop, ","); + while (tokens.hasMoreTokens()) { + String token = tokens.nextToken().trim(); + if (!token.equals("")) + list.addElement(token); + } + return list.isEmpty() ? new String[0] : (String[]) list.toArray(new String[0]); +} +/** + * Creates and returns a platform <code>BootLoader</code> which can be used to start + * up and run the platform. The given base, if not <code>null</code>, + * is the location of the boot loader code. If the value is <code>null</code> + * 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 <code>URL</code>-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 <code>URL</code>-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., <code>-application com.example.application</code>). + * After running the application <code>System.exit(N)</code> is executed. + * The value of N is derived from the value returned from running the application. + * If the application's return value is an <code>Integer</code>, N is this value. + * In all other cases, N = 0. + * <p> + * Clients wishing to run the platform without a following <code>System.exit</code> + * call should use <code>run()</code>. + * + * @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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/NewMain.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/NewMain.java new file mode 100644 index 00000000000..41a42bc7f30 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/NewMain.java @@ -0,0 +1,74 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.testplugin; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/TestPluginLauncher.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/TestPluginLauncher.java new file mode 100644 index 00000000000..4ee939df6b5 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/TestPluginLauncher.java @@ -0,0 +1,57 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/TestWorkbench.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/TestWorkbench.java new file mode 100644 index 00000000000..45bc1e8de3f --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/TestWorkbench.java @@ -0,0 +1,79 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/test/HelloWorld.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/test/HelloWorld.java new file mode 100644 index 00000000000..4e41ef027f1 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/test/HelloWorld.java @@ -0,0 +1,50 @@ +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ +package org.eclipse.cdt.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.testplugin.CProjectHelper; +import org.eclipse.cdt.testplugin.TestPluginLauncher; +import org.eclipse.core.runtime.Path; + + +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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/AccessibilityTestPass.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/AccessibilityTestPass.java new file mode 100644 index 00000000000..2a6e8fe44bd --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/AccessibilityTestPass.java @@ -0,0 +1,66 @@ +package org.eclipse.cdt.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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/DialogCheck.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/DialogCheck.java new file mode 100644 index 00000000000..8ef16ebce24 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/DialogCheck.java @@ -0,0 +1,225 @@ +package org.eclipse.cdt.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 <code>DialogCheck</code> is used test a dialog in + * various ways. + * <p> + * For interactive tests use <code>assertDialog</code>. + * For automated tests use <code>assert DialogTexts</code>. + * </p> + */ +public class DialogCheck { + private DialogCheck() { + } + private static VerifyDialog _verifyDialog; + + + /** + * Asserts that a given dialog is not null and that it passes + * certain visual tests. These tests will be verified manually + * by the tester using an input dialog. Use this assert method + * to verify a dialog's sizing, initial focus, or accessiblity. + * To ensure that both the input dialog and the test dialog are + * accessible by the tester, the getShell() method should be used + * when creating the test dialog. + * + * Example usage: + * <code>Dialog dialog = new AboutDialog( DialogCheck.getShell() ); + * DialogCheck.assertDialog(dialog, this);</code> + * + * @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/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/FailureDialog.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/FailureDialog.java new file mode 100644 index 00000000000..dbe98db5652 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/FailureDialog.java @@ -0,0 +1,107 @@ +package org.eclipse.cdt.testplugin.util; + + +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ + +import org.eclipse.swt.SWT; +import org.eclipse.swt.layout.GridData; +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.swt.widgets.Text; + +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.dialogs.IDialogConstants; +import org.eclipse.jface.resource.JFaceResources; + + +/* + * A dialog for collecting notes from the tester regarding + * the failure of a test. + */ +public class FailureDialog extends Dialog { + private Text _text; + private String _log; + private int SIZING_TEXT_WIDTH = 400; + private int SIZING_TEXT_HEIGHT = 200; + + /** + * Constructor for FailureDialog + */ + public FailureDialog(Shell parentShell) { + super(parentShell); + } + /* (non-Javadoc) + * Method declared on Window. + */ + protected void configureShell(Shell newShell) { + super.configureShell(newShell); + newShell.setText("Dialog Test Failed"); + } + /* (non-Javadoc) + * Method declared on Dialog. + */ + protected void createButtonsForButtonBar(Composite parent) { + createButton(parent, IDialogConstants.OK_ID, "&OK", true); + createButton(parent, IDialogConstants.CANCEL_ID, IDialogConstants.CANCEL_LABEL, false); + } + /* (non-Javadoc) + * Method declared on Dialog. + */ + protected Control createDialogArea(Composite parent) { + // page group + Composite composite = (Composite)super.createDialogArea(parent); + composite.setSize( composite.computeSize(SWT.DEFAULT, SWT.DEFAULT) ); + + Label label = new Label(composite, SWT.WRAP); + label.setText("&Enter a note regarding the failure:"); + + _text = new Text(composite, SWT.MULTI | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); + _text.setFont( JFaceResources.getFontRegistry().get(JFaceResources.TEXT_FONT) ); + GridData data = new GridData(GridData.FILL_BOTH); + data.widthHint = SIZING_TEXT_WIDTH; + data.heightHint = SIZING_TEXT_HEIGHT; + _text.setLayoutData(data); + + return composite; + } + /* (non-Javadoc) + * Method declared on Dialog. + */ + protected void okPressed() { + _log = _text.getText(); + super.okPressed(); + } + /* + * @return String the text contained in the input area of + * the dialog. + */ + String getText() { + if (_log == null) { + return "Empty entry."; + } else { + return _log; + } + } + /* + * Sets the text of the input area. This should only be + * called to set the initial text so only call before invoking + * open(). + */ + void setText(String text) { + _text.setText(text); + } + /* + * Returns a string representation of this class which + * the text contained in the input area of the dialog. + */ + public String toString() { + return getText(); + } +} + + diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/FocusTestPass.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/FocusTestPass.java new file mode 100644 index 00000000000..0f83e03c1c2 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/FocusTestPass.java @@ -0,0 +1,68 @@ +package org.eclipse.cdt.testplugin.util; + + +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ + +import java.util.ArrayList; + + +/* + * This test pass verifies the initial focus of a dialog + * when it is given focus. + */ +public class FocusTestPass implements IDialogTestPass { + private static final int CHECKLIST_SIZE = 1; + + + /** + * @see IDialogTestPass#title() + */ + public String title() { + return "Test Pass: Initial Focus"; + } + /** + * @see IDialogTestPass#description() + */ + public String description() { + return "Verify the initial focus of the dialogs."; + } + /** + * @see IDialogTestPass#label() + */ + public String label() { + return "&Initial Focus"; + } + /** + * @see IDialogTestPass#checkListTexts() + */ + public ArrayList checkListTexts() { + ArrayList list = new ArrayList(CHECKLIST_SIZE); + list.add("&1) the initial focus is appropriate."); + 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] = "The initial focus is inappropriate."; + return failureText; + } + /** + * @see IDialogTestPass#queryText() + */ + public String queryText() { + return "Is the initial focus of the dialog correct?"; + } + /** + * @see IDialogTestPass#getID() + */ + public int getID() { + return VerifyDialog.TEST_FOCUS; + } +}
\ No newline at end of file diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/IDialogTestPass.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/IDialogTestPass.java new file mode 100644 index 00000000000..be34fbadf8c --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/IDialogTestPass.java @@ -0,0 +1,48 @@ +package org.eclipse.cdt.testplugin.util; + + +import java.util.ArrayList; + + +/* + * Interface to describe a visual test pass for a dialog test. + */ +public interface IDialogTestPass { + /* + * @return String The title of the test pass. + */ + public String title(); + /* + * @return String The description of the test pass. + */ + public String description(); + /* + * @return String The label of the test pass to be used + * in a selection list. The return includes an '&' + * if a mnemonic is desired. + */ + public String label(); + /* + * @return ArrayList A list of items to appear in a checklist. + * The items in the list must be Strings and should include an + * '&' if a mnemonic is desired. + */ + public ArrayList checkListTexts(); + /* + * @return String[] Associated failure messages that correspond + * to the checklist items. The size of this array should be the + * same size as the checklist. + */ + public String[] failureTexts(); + /* + * @return String The test that corresponds to the test pass to + * which the tester will respond with a 'yes' or 'no'. + */ + public String queryText(); + /* + * @return int A unique number that identifies the test pass. + */ + public int getID(); +} + + diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/SizingTestPass.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/SizingTestPass.java new file mode 100644 index 00000000000..dc471637e66 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/SizingTestPass.java @@ -0,0 +1,76 @@ +package org.eclipse.cdt.testplugin.util; + + +/* + * (c) Copyright IBM Corp. 2000, 2001. + * All Rights Reserved. + */ + +import java.util.ArrayList; + + +/* + * This test pass verifies visually the sizing of the dialog and its + * widgets. + */ +class SizingTestPass implements IDialogTestPass { + private static final int CHECKLIST_SIZE = 5; + + + /** + * @see IDialogTestPass#title() + */ + public String title() { + return "Test Pass: Sizing and Display"; + } + /** + * @see IDialogTestPass#description() + */ + public String description() { + return "Verify the sizing and display of the dialogs and widgets."; + } + /** + * @see IDialogTestPass#label() + */ + public String label() { + return "&Sizing and Display"; + } + /** + * @see IDialogTestPass#checkListTexts() + */ + public ArrayList checkListTexts() { + ArrayList list = new ArrayList(CHECKLIST_SIZE); + list.add("&1) the correct dialog displays."); + list.add("&2) the dialog is an appropriate size for the required resolution (1024x768)."); + list.add("&3) the texts are correct and not cut off."); + list.add("&4) all strings have been externalized properly."); + list.add("&5) all the widgets are viewable and not cut off."); + 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] = "The wrong dialog displayed."; + failureText[1] = "The dialog is too large for the required resolution."; + failureText[2] = "Text labels are wrong or cut off."; + failureText[3] = "Some strings have not been externalized properly."; + failureText[4] = "Some widgets are cut off."; + return failureText; + } + /** + * @see IDialogTestPass#queryText() + */ + public String queryText() { + return "Is the sizing and display of the dialog correct?"; + } + /** + * @see IDialogTestPass#getID() + */ + public int getID() { + return VerifyDialog.TEST_SIZING; + } +}
\ No newline at end of file diff --git a/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/VerifyDialog.java b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/VerifyDialog.java new file mode 100644 index 00000000000..a28a1e43524 --- /dev/null +++ b/core/org.eclipse.cdt.ui.tests/src/org/eclipse/cdt/testplugin/util/VerifyDialog.java @@ -0,0 +1,305 @@ +package org.eclipse.cdt.testplugin.util; + + +import java.util.Iterator; + + +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.dialogs.IDialogConstants; +import org.eclipse.jface.dialogs.TitleAreaDialog; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.ShellAdapter; +import org.eclipse.swt.events.ShellEvent; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Group; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Shell; + + +/* + * This dialog is intended to verify a dialogs in a testing + * environment. The tester can test for sizing, initial focus, + * or accessibility. + */ +public class VerifyDialog extends TitleAreaDialog { + private int SIZING_WIDTH = 400; + + private static int TEST_TYPE; + public static final int TEST_SIZING = 0; + public static final int TEST_FOCUS = 1; + public static final int TEST_ACCESS = 2; + private IDialogTestPass _dialogTests[] = new IDialogTestPass[3]; + + + private Dialog _testDialog; //the dialog to test + private Point _testDialogSize; + + private Label _queryLabel; + private Button _yesButton; + private Button _noButton; + private Button _checkList[]; + private String _failureText; + + /* + * Create an instance of the verification dialog. + */ + public VerifyDialog(Shell parent) { + super(parent); + if ( !(TEST_TYPE <= 2) && !(TEST_TYPE >= 0) ) { + TEST_TYPE = TEST_SIZING; + } + _failureText = ""; + _dialogTests[0] = new SizingTestPass(); + _dialogTests[1] = new FocusTestPass(); + _dialogTests[2] = new AccessibilityTestPass(); + } + + /* (non-Javadoc) + * Method declared on Window. + */ + protected void configureShell(Shell newShell) { + super.configureShell(newShell); + newShell.setText("Dialog Verification"); + setShellStyle(SWT.NONE); + } + /* (non-Javadoc) + * Method declared on Dialog. + */ + protected void createButtonsForButtonBar(Composite parent) { + _yesButton = createButton(parent, IDialogConstants.YES_ID, IDialogConstants.YES_LABEL, true); + _noButton = createButton(parent, IDialogConstants.NO_ID, IDialogConstants.NO_LABEL, false); + } + /* (non-Javadoc) + * Method declared on Dialog. + */ + protected void buttonPressed(int buttonId) { + if (IDialogConstants.YES_ID == buttonId) { + setReturnCode(IDialogConstants.YES_ID); + if (_testDialog.getShell() != null) { + _testDialog.close(); + } + close(); + } else if (IDialogConstants.NO_ID == buttonId) { + handleFailure(); + } + } + /* (non-Javadoc) + * Method declared on Dialog. + */ + protected Control createDialogArea(Composite parent) { + // top level composite + Composite parentComposite = (Composite)super.createDialogArea(parent); + + + // create a composite with standard margins and spacing + Composite composite = new Composite(parentComposite, SWT.NONE); + composite.setSize(SIZING_WIDTH, SWT.DEFAULT); + GridLayout layout = new GridLayout(); + layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN); + layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN); + layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING); + layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING); + composite.setLayout(layout); + composite.setLayoutData(new GridData(GridData.FILL_BOTH)); + + + createTestSelectionGroup(composite); + createCheckListGroup(composite); + + + _queryLabel = new Label(composite, SWT.NONE); + _queryLabel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); + + initializeTest(); + return composite; + } + /* + * Group for selecting type of test. + */ + private void createTestSelectionGroup(Composite parent) { + Group group = new Group(parent, SWT.SHADOW_NONE); + group.setText("Testing:"); + group.setLayout( new GridLayout() ); + GridData data = new GridData(GridData.FILL_HORIZONTAL); + group.setLayoutData(data); + + for (int i = 0; i < _dialogTests.length; i++) { + Button radio = new Button(group, SWT.RADIO); + radio.setText( _dialogTests[i].label() ); + final int testID = _dialogTests[i].getID(); + radio.addSelectionListener(new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + TEST_TYPE = testID; + initializeTest(); + _yesButton.setEnabled(true); + } + }); + if ( TEST_TYPE == _dialogTests[i].getID() ) { + radio.setSelection(true); + } + } + } + /* + * Initializes the checklist with empty checks. + */ + private void createCheckListGroup(Composite parent) { + Group group = new Group(parent, SWT.SHADOW_NONE); + group.setText("Verify that:"); + group.setLayout( new GridLayout() ); + GridData data = new GridData(GridData.FILL_HORIZONTAL); + group.setLayoutData(data); + + int checkListSize = 0; + for (int i = 0; i < _dialogTests.length; i++) { + int size = _dialogTests[i].checkListTexts().size(); + if (size > checkListSize) { + checkListSize = size; + } + } + _checkList = new Button[checkListSize]; + SelectionAdapter selectionAdapter = new SelectionAdapter() { + public void widgetSelected(SelectionEvent e) { + checkYesEnable(); + } + }; + for (int i = 0; i < checkListSize; i++) { + _checkList[i] = new Button(group, SWT.CHECK); + _checkList[i].addSelectionListener(selectionAdapter); + data = new GridData(GridData.HORIZONTAL_ALIGN_FILL); + data.grabExcessHorizontalSpace = true; + _checkList[i].setLayoutData(data); + } + } + /* + * Disables the yes button if any of the items in the checklist + * are unchecked. Enables the yes button otherwise. + */ + private void checkYesEnable() { + boolean enable = true; + for (int i = 0; i < _checkList.length; i++) { + if ( !_checkList[i].getSelection() ) { + enable = false; + } + } + _yesButton.setEnabled(enable); + } + /* + * Initializes the checklist, banner texts, and query label + */ + private void initializeTest() { + IDialogTestPass test = _dialogTests[TEST_TYPE]; + setTitle( test.title() ); + setMessage( test.description() ); + Iterator iterator = test.checkListTexts().iterator(); + for (int i = 0; i < _checkList.length; i++) { + if ( iterator.hasNext() ) { + _checkList[i].setText( iterator.next().toString() ); + _checkList[i].setVisible(true); + _checkList[i].update(); + } else { + _checkList[i].setVisible(false); + _checkList[i].update(); + } + _checkList[i].setSelection(true); + } + _queryLabel.setText( test.queryText() ); + } + public String getFailureText() { + return _failureText; + } + /* + * Can't open the verification dialog without a specified + * test dialog, this simply returns a failure and prevents + * opening. Should use open(Dialog) instead. + * + */ + public int open() { + _failureText = "Testing dialog is required, use VerifyDialog::open(Dialog)"; + return IDialogConstants.NO_ID; + } + /* + * Opens the verification dialog to test the specified dialog. + */ + public int open(Dialog testDialog) { + if (getShell() == null) { + create(); + } + getShell().setLocation(0, 0); + getShell().setSize(Math.max(SIZING_WIDTH, getShell().getSize().x), getShell().getSize().y); + _testDialog = testDialog; + if (_testDialog.getShell() == null) { + _testDialog.create(); + } + _testDialogSize = _testDialog.getShell().getSize(); + openNewTestDialog(); + + return super.open(); + } + /* + * Opens the dialog to be verified. + */ + private void openNewTestDialog() { + if (_testDialog.getShell() == null) { + _testDialog.create(); + } + _testDialog.setBlockOnOpen(false); + _testDialog.getShell().setLocation(getShell().getSize().x + 1, 0); + _testDialog.getShell().setSize(_testDialogSize); + _testDialog.getShell().addShellListener(new ShellAdapter() { + public void shellClosed(ShellEvent e) { + e.doit = false; + } + + }); + _testDialog.open(); + } + /* + * The test dialog failed, open the failure dialog. + */ + private void handleFailure() { + IDialogTestPass test = _dialogTests[TEST_TYPE]; + StringBuffer text = new StringBuffer(); + String label = test.label(); + label = label.substring(0, label.indexOf("&")) + + label.substring(label.indexOf("&") + 1); + text.append(label). + append(" failed on the "). + append(SWT.getPlatform()). + append(" platform:\n"); + + String failureMessages[] = test.failureTexts(); + for (int i = 0; i < test.checkListTexts().size(); i++) { + if ( !_checkList[i].getSelection() ) { + text.append("- ").append(failureMessages[i]).append("\n"); + } + } + FailureDialog dialog = new FailureDialog( getShell() ); + dialog.create(); + String temp = text.toString(); + dialog.setText( text.toString() ); + if (dialog.open() == IDialogConstants.OK_ID) { + _failureText = dialog.toString(); + setReturnCode(IDialogConstants.NO_ID); + if (_testDialog.getShell() != null) { + _testDialog.close(); + } + close(); + } + } + /* + * In case the shell was closed by a means other than + * the NO button. + */ + protected void handleShellCloseEvent() { + handleFailure(); + } +} + + |