Attachment #47599 for bug #134254

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




        NLS.initializeMessages(BUNDLE_NAME, CommonPluginMessages.class);
    }

    public static String ADJUST_CLASSPATH;
	public static String ASSOCIATE_TEST_TO_SOURCE;
	public static String CREATE_CONTAINER;
	public static String CREATE_PACKAGE;
	public static String DEFAULT_PACKAGE;
	public static String DEFINE_SOURCE_FOLDER;
	public static String DELETE_FILE;
	public static String DELETING_FILE;
	public static String E_CODEGEN_PACK_DIAG;
    public static String E_CODEGEN_CLASS_DIAG;
    public static String E_CODEGEN_CLOSED_PROJECT;
    public static String E_CODEGEN_NO_SRCFOLDER;
    
    public static String _ERROR_LAUNCH_VALIDATOR;
    public static String _WARNING_LAUNCH_VALIDATOR;
	public static String E_COMP_UNIT_READ_ONLY;
	public static String GENERATE_CODE;
	public static String GENERATE_FILE;
	public static String GENERATING_FILE;
	public static String GENERIC_GENERATOR;
	public static String JavaGenerator_W_COMP_UNIT_UNSAVED_CHANGES;
	public static String MOVE_COMPILATION_UNIT;
	public static String MOVE_RENAME_COMPILATION_UNIT;
	public static String NO_FILE;
	public static String NO_SOURCE_FOLDER;
	public static String NOT_A_SOURCE_FOLDER;
	public static String NOT_IN_JAVA_PROJECT;
	public static String PROJECT_NOT_ACCESSIBLE;
	public static String READ_ONLY_FILE;
	public static String RENAME_COMPILATION_UNIT;
	public static String RESOURCE_NOT_ACCESSIBLE;
	public static String SETUP_CONTEXT;
	public static String UNKNOWN_LOCATION;
	public static String UPDATE_CODE;
    public static String VALIDATION_NO_HOST_NAME_ERROR;
    public static String VALIDATION_BAD_ROOTDIR_ERROR_;
    public static String _WARNING_BUILD_PATH_PROBLEM;
    public static String _WARNING_COMPILATION_PROBLEM;
	public static String W_COMP_UNIT_OVERWRITE;
}





E_CODEGEN_PACK_DIAG		= A problem was found with the package name: {0}. The code for this test suite cannot be generated until you adjust the package name.
E_CODEGEN_CLASS_DIAG	= A problem was found with the class name: {0}. The code for this test suite cannot be generated until you adjust the class name.
E_COMP_UNIT_READ_ONLY=Compilation unit {0} is read-only
E_CODEGEN_CLOSED_PROJECT= The source folder: {0} belongs to a closed project. The code for this test cannot be generated until the project is opened.
E_CODEGEN_NO_SRCFOLDER	= The test suite does not specify a source folder.


VALIDATION_NO_HOST_NAME_ERROR	= No host name found
VALIDATION_BAD_ROOTDIR_ERROR_	= {0}\nThis value for ROOTDIR does not match existing directory on the specified host: {1}
_WARNING_BUILD_PATH_PROBLEM		= Java build path errors exist in enclosing project: {0}.
_WARNING_COMPILATION_PROBLEM	= Compilation errors exist in enclosing project: {0}.
CREATE_PACKAGE=Create package {0}
CREATE_CONTAINER=Create container {0}
NO_SOURCE_FOLDER=Source folder doesn't exist
NOT_A_SOURCE_FOLDER=Package fragment root is not a source folder
NOT_IN_JAVA_PROJECT=Container {0} does not belong to a Java project
ASSOCIATE_TEST_TO_SOURCE=Associate test {0} to source {1}
NO_FILE=File does not exist
READ_ONLY_FILE=File is read-only
DELETING_FILE=Deleting file
DELETE_FILE=Delete file {0}
DEFINE_SOURCE_FOLDER=Define {0} as a source folder
RESOURCE_NOT_ACCESSIBLE=Resource {0} is not accessible
RENAME_COMPILATION_UNIT=Rename compilation unit {0} to {1}
ADJUST_CLASSPATH=Adjust classpath for project {0}
PROJECT_NOT_ACCESSIBLE=Project '{0}' is not accessible
GENERATE_FILE=Generate file {0}
GENERATE_CODE=Generate code
UNKNOWN_LOCATION=Unknown location for file 
GENERATING_FILE=Generating file
GENERIC_GENERATOR=Generic TPTP code generator
SETUP_CONTEXT=Setup context
UPDATE_CODE=Update code
MOVE_RENAME_COMPILATION_UNIT=Move compilation unit {0} to package {1} and rename it to {2}
MOVE_COMPILATION_UNIT=Move compilation unit {0} to package {1}
W_COMP_UNIT_OVERWRITE=Compilation unit {0} will be overwritten
DEFAULT_PACKAGE=(default package)
JavaGenerator_W_COMP_UNIT_UNSAVED_CHANGES=Compilation unit {0} has unsaved changes. Code update may be unaccurate.




 **********************************************************************/
package org.eclipse.hyades.test.tools.core.internal.common.codegen;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.hyades.models.common.facades.behavioral.ITestCase;
import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.AdjustSourceContainerChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.CreatePackageFragmentChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.MoveCompilationUnitChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.PotentialChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.ProjectAdjustChange;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.NullChange;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Abstract Java code generator.
 * <p>Although this abstract class does not implement any code generation
 * or code update, it provides additional features for generating java code, and also
 * makes additional assumptions about the test suite behavior model.</p>
 * <p>Sub-classes must implement {@link Generator#generateCode(IProgressMonitor)}, and
 * need to redefine {@link #createSourceUpdateChange(SubProgressMonitor)} if code update
 * is desired.</p>
 * <p>Sub-classes may also redefine {@link #computeTestMethodNames(ITestSuite, boolean, Helper)},
 * and extend {@link #createAdjustProjectClasspathChange(IProgressMonitor)},
 * {@link #createPreCodegenerationChange(IProgressMonitor)},
 * {@link Generator#createPostCodegenerationChange(IProgressMonitor)}, and all conditions
 * checking methods.</p>
 * @author marcelop, jcanches
 * @since 1.0.1
 */
abstract public class JavaGenerator extends Generator {
	
	private IProjectDependencyUpdater projectDependencyUpdater;
	
	/**
	 * Creates a JavaGenerator for a Java test suite.
	 * @param testSuite
	 * @param updater A Project dependency updater that will perform project
	 * adjustment to comply with additional classpath requirements.
	 */
	protected JavaGenerator(ITestSuite testSuite, IProjectDependencyUpdater updater) {
		super(testSuite);
		this.projectDependencyUpdater = updater;
	}
	
	/**
	 * Creates the change that adjusts the project classpath.
	 * <p>This implementation creates a change that invokes the generator's project
	 * dependency updater.</p>
	 * <p>Sub-classes may extend or redefine this implementation.</p> 
	 * @param monitor
	 * @return
	 * @throws CoreException
	 */
	protected Change createAdjustProjectClasspathChange(IProgressMonitor monitor) throws CoreException {
		monitor.beginTask("", 1); //$NON-NLS-1$
		try {
			IProject project = getFileHandle(getTestSuite()).getProject();
			Collection dependentProjects = getDependentProjects(getTestSuite(), project);
			for(Iterator it = dependentProjects.iterator(); it.hasNext(); ) {
				projectDependencyUpdater.addRequiredProject((IProject)it.next());
			}
			if (!projectDependencyUpdater.previewAdjustProject(project).isEmpty()) {
				monitor.worked(1);
				return new ProjectAdjustChange(projectDependencyUpdater, project);
			} else {
				monitor.worked(1);
				return null;
			}
		} finally {
			monitor.done();
		}
	}
	
	protected IPackageFragmentRoot getPackageFragmentRoot(ITestSuite ts) {
		IContainer container = getSourceContainerHandle(ts);
		IJavaElement javaElement = JavaCore.create(container);
		if (javaElement instanceof IJavaProject) {
			IJavaProject jproject = (IJavaProject)javaElement;
			return jproject.getPackageFragmentRoot(container);
		} else if (javaElement instanceof IPackageFragmentRoot) {
			return (IPackageFragmentRoot)javaElement;
		}
		return null;
	}
	
	protected IPackageFragment getPackageFragment(ITestSuite ts) {
		IPackageFragmentRoot root = getPackageFragmentRoot(ts);
		if (root == null) return null;
		return root.getPackageFragment(getPackageName(ts));
	}
	
	protected ICompilationUnit getCompilationUnit(ITestSuite ts) {
		IPackageFragment pack = getPackageFragment(ts);
		if (pack != null) {
			return pack.getCompilationUnit(getClassName(ts) + ".java"); //$NON-NLS-1$
		}
		return null;
	}
	
	/**
	 * Returns the package name that the generated class must belong to.
	 * @return A Java package name.
	 */
	protected String getPackageName(ITestSuite ts) {
		String cls = ts.getImplementor().getResource();
		String packageName;
		int index = cls.lastIndexOf('.');
		if (index == -1) {

		return packageName;
	}
	
	/**
	 * Returns the class name of the generated class.
	 * @return
	 */
	protected String getClassName(ITestSuite ts) {
		String cls = ts.getImplementor().getResource();
		String className;
		int index = cls.lastIndexOf('.');
		if (index == -1) {

		return className;
	}
	
	/**
	 * In addition to its super implementation, this implementation creates a change that ensures 
	 * that the source container is a source folder, creates the package, and adjusts the project
	 * classpath if necessary.
	 */
	protected Change createPreCodegenerationChange(IProgressMonitor monitor) throws CoreException
	{
		monitor.beginTask("", 10); //$NON-NLS-1$
		try {
			CompositeChange change = new CompositeChange(CommonPluginMessages.SETUP_CONTEXT);
			addPotentialChange(super.createPreCodegenerationChange(monitor), change);
			addPotentialChange(createAdjustSourceContainerChange(), change);
			addPotentialChange(createCreatePackageChange(), change);
			addPotentialChange(createAdjustProjectClasspathChange(new SubProgressMonitor(monitor, 1)), change);
			return packCompositeChange(change);
		} finally {
			monitor.done();
		}
	}
	
	/**
	 * Helper method to create a change that makes sure that the source container is a java
	 * source folder.
	 * @return
	 */
	final protected Change createAdjustSourceContainerChange() {
		PotentialChange change = new AdjustSourceContainerChange(getSourceContainerHandle(getTestSuite()));
		if (change.hasEffect()) return change;
		else return new NullChange();
	}
	
	/**
	 * Helper method to create a change that creates the package, if necessary.
	 */
	final protected Change createCreatePackageChange() {
		IJavaProject jproject = JavaCore.create(getSourceContainerHandle(getTestSuite()).getProject());
		IPackageFragmentRoot sourceFolder = jproject.getPackageFragmentRoot(getSourceContainerHandle(getTestSuite()));
		PotentialChange change = new CreatePackageFragmentChange(sourceFolder, getPackageName(getTestSuite()));
		if (change.hasEffect()) return change;
		else return new NullChange();
	}

	protected final Change createUpdateChange(IFile file, IProgressMonitor monitor) throws CoreException, UnsupportedOperationException {
		monitor.beginTask("", 2); //$NON-NLS-1$
		try {
			Change sourceUpdateChange = createSourceUpdateChange(file, new SubProgressMonitor(monitor, 1));
			CompositeChange change = new CompositeChange(CommonPluginMessages.UPDATE_CODE);
			addPotentialChange(createAdjustProjectClasspathChange(new SubProgressMonitor(monitor, 1)), change);
			addPotentialChange(sourceUpdateChange, change);
			addPotentialChange(createCreatePackageChange(), change);
			addPotentialChange(createMoveCompilationUnitChange(), change);
			addPotentialChange(createPostCodegenerationChange(new SubProgressMonitor(monitor, 1)), change);
			change.markAsSynthetic();
			return packCompositeChange(change);
		} finally {
			monitor.done();
		}
	}
	
	/**
	 * Creates a move compilation unit change, if necessary (i.e. if the classes in the
	 * previous and in the current versions of the model are different).
	 * @return
	 */
	private Change createMoveCompilationUnitChange() {
		ITestSuite previous = getRepositoryTestSuite();
		if (previous != null) {
			IFile file = getFileHandle(previous);
			IFile newFile = getFileHandle(getTestSuite());
			if (!newFile.equals(file)) {
				// Change destination
				if (file.exists()) {
					ICompilationUnit cu = JavaCore.createCompilationUnitFrom(file);
					if (cu.exists()) {
						IPackageFragment newPackage = getPackageFragment(getTestSuite());
						return new MoveCompilationUnitChange(cu, newPackage, newFile.getName());
					}
				}
			}
		}
		return null;
	}

	/**
	 * Creates the source update change. This implementation throws a {@link UnsupportedOperationException}.
	 * Sub-classes need to redefine this method in order to be code-update-capable.
	 * @file The file to update. This is not always equal to getFileHandle(), when there
	 * is a source file move involved during the generation.
	 * @param monitor A progress monitor
	 * @return
	 * @throws CoreException, UnsupportedOperationException
	 */
	protected Change createSourceUpdateChange(IFile file, SubProgressMonitor monitor) throws CoreException, UnsupportedOperationException {
		throw new UnsupportedOperationException();
	}

	/**
	 * In addition to its super implementation, this implementation checks that the package name
	 * and class name are valid.
	 */
	public RefactoringStatus checkInitialConditions(IProgressMonitor monitor) throws CoreException, OperationCanceledException {
		monitor.beginTask("", 4); //$NON-NLS-1$
		try {
			// Super validation
			RefactoringStatus status = super.checkInitialConditions(new SubProgressMonitor(monitor, 2));
			
			// Package name
			String packageName = getPackageName(getTestSuite());
			if (packageName.length() > 0) {
				IStatus st = JavaConventions.validatePackageName(packageName);
				if (st.getSeverity() != IStatus.OK) {
					if (st.getSeverity() == IStatus.ERROR) {
						// Replace the diagnosis of JDT with something more explicit
						status.addFatalError(NLS.bind(CommonPluginMessages.E_CODEGEN_PACK_DIAG, st.getMessage()));
					}
				}
			}
			monitor.worked(1);
			
			// Class name
			String className = getClassName(getTestSuite());
			IStatus st = JavaConventions.validateJavaTypeName(className);
			if (st.getSeverity() != IStatus.OK) {
				if (st.getSeverity() == IStatus.ERROR) {
					// Replace the diagnosis of JDT with something more explicit
					status.addFatalError(NLS.bind(CommonPluginMessages.E_CODEGEN_CLASS_DIAG, st.getMessage()));
				}
				return status;
			}
			monitor.worked(1);
			
			ITestSuite previous = getRepositoryTestSuite();
			ICompilationUnit cu;
			if (previous != null) {
				cu = getCompilationUnit(previous);
			} else {
				cu = getCompilationUnit(getTestSuite());
			}
			if (cu != null && cu.hasUnsavedChanges()) {
				status.addError(NLS.bind(CommonPluginMessages.JavaGenerator_W_COMP_UNIT_UNSAVED_CHANGES, cu.getElementName()));
			}
			return status;
		} finally {
			monitor.done();
		}
		
		// Otherwise OK
		return Status.OK_STATUS;
	}
	
	/**
	 * Computes the names of the test methods associated to the test cases of the specified test
	 * suite. Test methods names should be typically stored in the model.
	 * @param testSuite
	 * @param isExternalBehavior
	 * @param helper
	 * @see Helper#setTestMethodName(ITestCase, String)
	 */
	protected void computeTestMethodNames(ITestSuite testSuite, boolean isExternalBehavior, Helper helper) {
		Iterator it = testSuite.getITestCases().iterator();
		while (it.hasNext()) {

		}
	}
	
	public IFile getFileHandle(ITestSuite ts) {
		IContainer sourceContainer = getSourceContainerHandle(ts);
		return sourceContainer.getFile(new Path(ts.getImplementor().getResource().replace('.','/') + ".java")); //$NON-NLS-1$
		return sourceContainer.getFile(new Path(testSuite.getImplementor().getResource().replace('.','/') + ".java")); //$NON-NLS-1$
	}
			
	protected void adjustSourceContainer(IContainer sourceContainer, String packageName, IProgressMonitor monitor)
	throws Exception
	{
		IJavaProject javaProject = JavaCore.create(sourceContainer.getProject());
		if(sourceContainer.getType() == IResource.FOLDER)
		{
			if(!javaProject.isOnClasspath(sourceContainer))
			{
				IClasspathEntry entry = JavaCore.newSourceEntry(sourceContainer.getFullPath());
				List entries = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
				entries.add(1, entry);
				javaProject.setRawClasspath((IClasspathEntry[])entries.toArray(new IClasspathEntry[entries.size()]), monitor);
			}
		}
		
		javaProject.getPackageFragmentRoot(sourceContainer).createPackageFragment(packageName, true, monitor);
	}
	
	protected static Collection getDependentProjects(ITestSuite testSuite, IProject project)
	{
		if((testSuite.getIReferencedSuites() == null) || (testSuite.getIReferencedSuites().isEmpty()))

		return entries;
	}

	public IProjectDependencyUpdater getProjectDependencyUpdater() {
		return projectDependencyUpdater;
	}
	
}

Lines 26-36 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/Helper.java (+145 lines)
26	import org.eclipse.hyades.test.core.util.EMFUtil;	26	import org.eclipse.hyades.test.core.util.EMFUtil;
27	import org.eclipse.hyades.test.core.util.JavaUtil;	27	import org.eclipse.hyades.test.core.util.JavaUtil;
28	import org.eclipse.hyades.test.tools.core.CorePlugin;	28	import org.eclipse.hyades.test.tools.core.CorePlugin;
		29	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.CompilationUnitChange;
		30	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.DeleteFileChange;
		31	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.MoveCompilationUnitChange;
		32	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.ProjectAdjustChange;
29	import org.eclipse.jdt.core.ICompilationUnit;	33	import org.eclipse.jdt.core.ICompilationUnit;
30	import org.eclipse.jdt.core.JavaModelException;	34	import org.eclipse.jdt.core.JavaModelException;
31	import org.eclipse.jdt.core.ToolFactory;	35	import org.eclipse.jdt.core.ToolFactory;
		36	import org.eclipse.jdt.core.dom.CompilationUnit;
		37	import org.eclipse.jdt.core.dom.ImportDeclaration;
32	import org.eclipse.jdt.core.formatter.CodeFormatter;	38	import org.eclipse.jdt.core.formatter.CodeFormatter;
33	import org.eclipse.jface.text.Document;	39	import org.eclipse.jface.text.Document;
		40	import org.eclipse.ltk.core.refactoring.Change;
		41	import org.eclipse.ltk.core.refactoring.CompositeChange;
34	import org.eclipse.text.edits.TextEdit;	42	import org.eclipse.text.edits.TextEdit;
35		43
36	/**	44	/**
Lines 353-358 Link Here
353	cu.createImport(importName, /sibling/null, /progressMonitor/null);	361	cu.createImport(importName, /sibling/null, /progressMonitor/null);
354	}	362	}
355	}	363	}
		364
		365	public void emitSortedImports(CompilationUnit cu) {
		366	Iterator it = importManager.getImports().iterator();
		367	while (it.hasNext()) {
		368	String importName = (String) it.next();
		369	if (!ASTHelper.hasImport(cu, importName)) {
		370	ImportDeclaration id = cu.getAST().newImportDeclaration();
		371	id.setName(cu.getAST().newName(importName));
		372	cu.imports().add(id);
		373	}
		374	}
		375	// TODO Remove unused imports
		376	}
356		377
357	public String getImportedName(String qualifiedName)	378	public String getImportedName(String qualifiedName)
358	{	379	{
Lines 424-427 Link Here
424	public String getSuperclassName() {	445	public String getSuperclassName() {
425	return superClassName;	446	return superClassName;
426	}	447	}
		448
		449	/**
		450	* Compares two strings appearing within a java comment/javadoc comment and return true
		451	* if they contain the same strings, ignoring differences such as line breaks, tabs and
		452	* space indentation.
		453	* @param comment1
		454	* @param comment2
		455	* @return
		456	*/
		457	public static boolean compareJavaComments(CharSequence comment1, String comment2) {
		458	// Compare character by character, ignoring separating characters
		459	final String separators = "\n\r\t "; //$NON-NLS-1$
		460	StringIterator i1 = new StringIterator(comment1, separators);
		461	StringIterator i2 = new StringIterator(comment2, separators);
		462	while(i1.hasNextCharacter() && i2.hasNextCharacter()) {
		463	if (i1.getNextCharacter() != i2.getNextCharacter()) return false;
		464	}
		465	return !i1.hasNextCharacter() && !i2.hasNextCharacter();
		466	}
		467
		468	/**
		469	* String iterator that iterates character by character through a string. It has
		470	* the ability to group a certain class of characters, replacing a sequence of one or
		471	* more of such characters by a single space.
		472	* @author jcanches
		473	*/
		474	public static class StringIterator {
		475	private int currentIndex;
		476	private int length;
		477	private CharSequence string;
		478	private String spaceCharacters;
		479	private boolean issueSpace;
		480	public StringIterator(CharSequence string, String spaceCharacters) {
		481	this.string = string;
		482	this.length = string.length();
		483	this.spaceCharacters = spaceCharacters;
		484	this.currentIndex = 0;
		485	this.issueSpace = false;
		486	skipIgnoredCharacters();
		487	}
		488	private void skipIgnoredCharacters() {
		489	while (currentIndex < length
		490	&& spaceCharacters.indexOf(string.charAt(currentIndex)) != -1) {
		491	issueSpace = true;
		492	currentIndex++;
		493	}
		494	}
		495	public boolean hasNextCharacter() {
		496	return issueSpace \|\| currentIndex < length;
		497	}
		498	public char getNextCharacter() {
		499	if (issueSpace) {
		500	issueSpace = false;
		501	return ' ';
		502	}
		503	char ret = string.charAt(currentIndex++);
		504	skipIgnoredCharacters();
		505	return ret;
		506	}
		507	}
		508
		509	public static class LineIterator {
		510	private final static String lineDelimiters = "\n\r"; //$NON-NLS-1$
		511	private StringIterator iterator;
512	private String nextLine;
513	public LineIterator(CharSequence string, String spaceCharacters) {
514	this.iterator = new StringIterator(string, spaceCharacters);
515	computeNextLine();
516	}
517	public boolean hasNextLine() {
518	return nextLine != null;
519	}
520	public String getNextLine() {
521	String ret = nextLine;
522	computeNextLine();
523	return ret;
524	}
525	private void computeNextLine() {
526	StringBuffer line = new StringBuffer();
527	boolean lineBegins = true;
528	while (iterator.hasNextCharacter()) {
529	char c = iterator.getNextCharacter();
530	if (lineBegins) {
531	if (c == ' ' \|\| lineDelimiters.indexOf(c) != -1) {
532	continue;
533	}
534	lineBegins = false;
535	}
536	if (lineDelimiters.indexOf(c) == -1) {
537	line.append(c);
538	} else {
539	break;
540	}
541	}
542	nextLine = line.toString().trim();
543	if (nextLine.length() == 0) nextLine = null;
544	}
545	}
546
547	public static boolean isDestructiveChange(Change change) {
548	if (change instanceof ProjectAdjustChange) {
549	return true;
550	}
551	if (change instanceof CompilationUnitChange) {
552	return ((CompilationUnitChange)change).isDestructive();
553	}
554	if (change instanceof MoveCompilationUnitChange) {
555	return true;
556	}
557	if (change instanceof DeleteFileChange) {
558	return true;
559	}
560	if (change instanceof CompositeChange) {
561	CompositeChange cchange = (CompositeChange)change;
562	Change[] children = cchange.getChildren();
563	for (int i = 0; i < children.length; i++) {
564	Change c = children[i];
565	if (isDestructiveChange(c)) return true;
566	}
567	return false;
568	}
569	return false;
570	}
571
427	}	572	}





package org.eclipse.hyades.test.tools.core.internal.common.codegen;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

/**
 * Updates a project dependencies (usually for the purpose of updating the classpath
 * available to this project). Implementations should not perform any modification until
 * {@link #adjustProject(IProject, IProgressMonitor)} is called.
 * @author jcanches
 * @since 4.2
 */
public interface IProjectDependencyUpdater {


	 * Add to the project dependencies the specified plugin.
	 * @param pluginName The name of the required plugin.
	 * @param jarName An optional jar name. This parameter may be used as a hint
	 * by some implementations. <code>null</code> is valid and means that the complete
	 * libraries of the specified plugin should be taken into account.
	 */
	void addRequiredPlugin(String pluginId, String jarName);

	 */
	void adjustProject(IProject project, IProgressMonitor monitor) throws CoreException;
	
	/**
	 * Determines which changes the call to adjustProject would make.
	 * @param project
	 * @return A collection of strings indicating the dependencies that need to be added to
	 * the project. An empty list indicates that the project is already up-to-date
	 * and does not need adjusting.
	 */
	Collection previewAdjustProject(IProject project);
	
}




import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.ILibrary;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.emf.common.util.URI;
import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.models.common.util.IDisposable;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.osgi.util.ManifestElement;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;

public class JavaProjectDependencyUpdater implements IProjectDependencyUpdater, IDisposable {


		if(pluginId == null)
			return new String[0];

		Bundle bundle = Platform.getBundle(pluginId);

		Plugin plugin;
		String requires = (String)bundle.getHeaders().get(Constants.BUNDLE_CLASSPATH);
		try {
			ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, requires);
			List libraries = new ArrayList(elements.length);
			for(int i = 0, maxi = elements.length; i < maxi; i++) {
				String variablePluginLibrary = getVariablePluginLibrary(pluginId, elements[i].getValue());
				libraries.add(variablePluginLibrary);
			}
			return (String[])libraries.toArray(new String[libraries.size()]);
		} catch (BundleException e) {
			CorePlugin.logError(e);
			return new String[0];
		}
		return (String[])libraries.toArray(new String[libraries.size()]);
	}
	
	protected static String getVariablePluginLibrary(String pluginId, String library)

			return ""; //$NON-NLS-1$

		try {
			URL url = FileLocator.resolve(bundle.getEntry("")); //$NON-NLS-1$
			IPath pluginPath = new Path(url.getFile());
			if (url.getProtocol().equals("jar"))  //jar in the plugin root //$NON-NLS-1$
			{

			
			IPath eclipseHomePath = JavaCore.getClasspathVariable(ECLIPSE_HOME);
			
			
			// On Windows, sometimes the case of the device for the plugin does
			// not match the case of the device for the eclipseHomePath.
			// This would never happen on *nix, because it the cases were different,


	}

	public Collection previewAdjustProject(IProject project) {
		if((requiredLibraries == null || requiredLibraries.isEmpty())
				&& (requiredProjects == null || requiredProjects.isEmpty())) return Collections.EMPTY_SET;
				
			IJavaProject javaProject = JavaCore.create(project);
			IClasspathEntry[] resolvedClasspath;
			List additionalClasspathEntries = new ArrayList();
			try {
				resolvedClasspath = javaProject.getResolvedClasspath(/*ignoreUnresolvedEntries*/true);
			} catch (JavaModelException e) {
				CorePlugin.logError(e);
				return Collections.EMPTY_SET;
			}
			
			HashSet result = new HashSet();
			
			if (requiredLibraries != null) {
				for (Iterator it = requiredLibraries.iterator(); it.hasNext();) {
					IClasspathEntry entry = getLibrariesEntry((String)it.next());
					if (!classpathContains(resolvedClasspath, entry)) {
						result.add(entry.getPath().toString());
					}
				}
			}
			
			if (requiredProjects != null) {
				for(Iterator it = requiredProjects.iterator(); it.hasNext();) {
					IProject dproject = (IProject)it.next();
					IClasspathEntry entry = getProjectEntry(dproject);
					if(!classpathContains(resolvedClasspath, entry)) {
						result.add(dproject.getName());
					}
				}
			}
			
			return result;
	}

}




import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
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.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.models.common.testprofile.TPFTestSuite;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.CreateContainerChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.CreateFileChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.DeleteFileChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.PotentialChange;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.NullChange;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Abstract code generator / code updater.<br>
 * <p>The typical use of the generator to generate the code for a test suite is:
 * <pre>
 * Generator generator = new Generator(testSuite);
 * if (generator.checkAllConditions(new SubProgressMonitor(pm, 1)).isOk()) {
 *   Change change = generator.createChange(new SubProgressMonitor(pm, 1));
 *   change.perform(new SubProgressMonitor(pm, 1));
 * }
 * </pre>
 * Since this class implements Refactoring, it can also be used in the context of a refactor
 * wizard (see {@link org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation}).</p>
 * <p>As of release 4.3, the Generator class has been completely redesigned, and now extends
 * the Refactoring framework provided by Eclipse SDK. This allows the user to preview
 * the changes implied by code generation/code update, and also to revert these changes.</p>
 * <p>This class is abstract. Sub-classes must provide {@link #generateCode(IProgressMonitor)}.
 * Optionally, if specific actions are needed before and/or after code generation, they can
 * extend {@link #createPreCodegenerationChange(IProgressMonitor)} and
 * {@link #createPostCodegenerationChange(IProgressMonitor)}.
 * If code update is desired they must override {@link #createUpdateChange(IFile, IProgressMonitor)}.
 * If additional checkings are needed, sub-classes may extend {@link #checkInitialConditions(IProgressMonitor)},
 * {@link #checkFinalConditions(IProgressMonitor)} and {@link #checkAllConditions(IProgressMonitor)}.
 * </p>
 * <p>The location and name of the generated file may be customized by overriding the methods
 * {@link #getFileHandle(ITestSuite)} and {@link #getSourceContainerHandle(ITestSuite)}.</p>
 * <p>A couple of helper methods are available to sub-classes: to manipulate Changes, see 
 * {@link #addPotentialChange(Change, CompositeChange)} and {@link #packCompositeChange(CompositeChange)}.</p>
 * <p>The package {@link org.eclipse.hyades.test.tools.core.internal.common.codegen.changes} provides a
 * library of pre-defined Changes for achieving various actions related to code-generation.</p>
 * <p>For classes that generate java code, consider extending {@link JavaGenerator}.</p>
 * @author marcelop, jcanches
 * @since 1.0.1
 */
abstract public class Generator extends Refactoring
{
	public static final String CHARSET_UTF8 = "UTF-8"; //$NON-NLS-1$
	
	private ITestSuite testSuite;
	private ITestSuite cachedRepositoryTestSuite;
	private boolean cachedRepositoryComputed = false;
	
	/**
	 * Instantiates a generator for the specified test suite.
	 * folders, packages and adjusting the project's classpath.
	 * 
	 * <p>The location of the test suite's implementor must be equals to the source
	 * container (ie, project and source folder).  The implementor's resource must
	 * be equals to the full class name (ie, package and class name).
	 *  
	 * @param testSuite
	 * @param monitor
	 * @throws Exception
	 */
	protected Generator(ITestSuite testSuite) {
		this.testSuite = testSuite;
	}
	
	/**
	 * Returns the test suite for which this generator is generating or updating code.
	 * @return
	 */
	final public ITestSuite getTestSuite() {
		return testSuite;
	}
	
	/**
	 * Returns the test suite as it is currently persisted on disk. This allows
	 * to compare models before and after modification.
	 * @return A test suite model, or <code>null</code> if the test suite model is
	 * new and has never been persisted.
	 */
	final protected ITestSuite getRepositoryTestSuite() {
		if (!cachedRepositoryComputed) {
			TPFTestSuite ts = (TPFTestSuite)getTestSuite();
			Resource res = ts.eResource();
			if (res != null) {
				URI uri = EcoreUtil.getURI(ts);
				ResourceSet rs = new ResourceSetImpl();
				try {
					EObject object = rs.getEObject(uri, /*loadOnDemand*/true);
					if (object != null && object instanceof ITestSuite) {
						cachedRepositoryTestSuite = (ITestSuite)object;
					}
				} catch (Throwable t) {
					// In 99% this is because the resource does not exist.
					cachedRepositoryTestSuite = null;
				}
			}
			cachedRepositoryComputed = true;
		}
		return cachedRepositoryTestSuite;
	}
	
	/**
	 * Add a change to a composite change, if this change has a real effect.
	 * A change is considered to have an effect if it not <code>null</code>, if it is not
	 * an instance of {@link NullChange}, and if it is not an instance of {@link PotentialChange},
	 * unless this potential change reports to be required.
	 * @param change A change or <code>null</code>.
	 * @param composite The composite change that will receive the change if necessary.
	 */
	protected final void addPotentialChange(Change change, CompositeChange composite) {
		if (change != null) {
			if (change instanceof NullChange) return;
			if (change instanceof PotentialChange && !((PotentialChange)change).hasEffect()) return;
			composite.add(change);
		}
	}
	
	/**
	 * Pack a composite change. If the composite change
	 * has zero children, a {@link NullChange} is returned. Otherwise, the composite itself is
	 * returned.
	 * @param change
	 * @return
	 */
	protected final Change packCompositeChange(CompositeChange change) {
		if (change.getChildren().length > 0) return change;
		return new NullChange();
	}
	
	/**
	 * This implementation always return a OK status.
	 */
	public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException, OperationCanceledException {
		pm.beginTask("", 1); //$NON-NLS-1$
		try {
			return new RefactoringStatus();
		} finally {
			pm.done();
		}
	}

	/**
	 * This implementation checks existence of the source container, and the accessibility of its project.
	 */
	public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException, OperationCanceledException {
		pm.beginTask("", 2); //$NON-NLS-1$
		try {
			RefactoringStatus status = new RefactoringStatus();
			IContainer container = getSourceContainerHandle(testSuite);
			pm.worked(1);
			if (container == null) {
				status.addError(CommonPluginMessages.E_CODEGEN_NO_SRCFOLDER);
			} else {
				IProject project = container.getProject();
				if (project.exists() && !project.isOpen()) {
					status.addError(NLS.bind(CommonPluginMessages.E_CODEGEN_CLOSED_PROJECT, container.getFullPath().toString()));
				}
				pm.worked(1);
			}
			return status;
		} finally {
			pm.done();
		}
	}

	final public Change createChange(IProgressMonitor monitor) throws CoreException, OperationCanceledException {
		Change change = null;
		IFile file = getFileHandle(testSuite);
		ITestSuite previous = getRepositoryTestSuite();
		if (previous != null) {
			file = getFileHandle(previous);
		}
		if(file != null && file.exists()) {
			try {
				change = createUpdateChange(file, monitor);
				mustGenerate = false;
			} catch (UnsupportedOperationException e) {
				//Fall back to code generation.
			}
		}
		if (change == null) {
			change = createGenerateChange(monitor);
		}
		return change;
	}

	public String getName() {
		return CommonPluginMessages.GENERIC_GENERATOR;
	}

	private Change createGenerateChange(IProgressMonitor monitor) throws CoreException {
		monitor.beginTask("", 6); //$NON-NLS-1$
		try {
			CompositeChange change = new CompositeChange(CommonPluginMessages.GENERATE_CODE);
			Change subChange = createPreCodegenerationChange(new SubProgressMonitor(monitor, 1));
			if (subChange != null) {
				change.add(subChange);
			}
			IFile file = getFileHandle(testSuite);
			if (file.exists()) {
				change.add(new DeleteFileChange(file));
			}
			monitor.worked(1);
			String code = generateCode(monitor);
			change.add(new CreateFileChange(file, code, CHARSET_UTF8));
			monitor.worked(3);
			subChange = createPostCodegenerationChange(new SubProgressMonitor(monitor, 1));
			if (subChange != null) {
				change.add(subChange);
			}
			return change;
		} finally {
			monitor.done();
		}
	}
	
	/**
	 * This implementation creates the source container, if it does not exist.
	 * @param monitor
	 * In the two latter cases, a message describes the reason(s) why code cannot
	 * be generated. This method should typically be called prior to invoking
	 * generate(). generate() would typically throw an exception if this method returns
	 * an error status.
	 * @param testSuite
	 * @return
	 * @throws CoreException
	 */
	protected Change createPreCodegenerationChange(IProgressMonitor monitor) throws CoreException {
		monitor.beginTask("", 1); //$NON-NLS-1$
		try {
			IContainer sourceContainer = getSourceContainerHandle(testSuite);
			if (!sourceContainer.exists()) {
				return new CreateContainerChange(sourceContainer);
			}
			return new NullChange();
		} finally {
			monitor.done();
		}
		return Status.OK_STATUS;
	}
	
	/**
	 * This implementation does nothing.
	 * @param monitor
	 * @return
	 * @throws CoreException
	 */
	protected Change createPostCodegenerationChange(IProgressMonitor monitor) throws CoreException {
		monitor.beginTask("", 1); //$NON-NLS-1$
		try {
			return new NullChange();
		} finally {
			monitor.done();
		}
	}
	
	/**
	 * Creates the change that describes the update of the specified file.
	 * <p>This implementation throws a {@link UnsupportedOperationException}. If code update
	 * is desired, the sub-class must override this implementation.</p>
	 * @param file The file to update
	 * @param monitor A progress monitor
	 * @return A change describing the update.
	 * @throws CoreException if the update creation failed, UnsupportedOperationException if code
	 * update is not supported.
	 */
	protected Change createUpdateChange(IFile file, IProgressMonitor monitor) throws CoreException, UnsupportedOperationException {
		throw new UnsupportedOperationException();
	}
		
	/**
	 * Returns the generated file. This is handle-only method, i.e. the returned file is
	 * not required to exist. 
	 * @return The generated file.
	 */
	public IFile getFileHandle(ITestSuite ts) {
		IContainer sourceContainer = getSourceContainerHandle(ts);
		return sourceContainer.getFile(new Path(ts.getImplementor().getResource()));
	}
	
	/**
	 * Returns the container that will receive the generated file.
	 * @return
	 */
	final protected IContainer getSourceContainerHandle(ITestSuite ts) {
		IContainer container = null;
		String location = ts.getImplementor().getLocation();
		if (location != null) {
			IPath path = new Path(location);
			if(path.segmentCount() == 1) {

		return container;
	}
	
	/**
	 * Generates the code for the test suite. The code will be placed in the file returned
	 * by {@link #getFileHandle()}.
	 * @param monitor A progress monitor
	 * @return Source code.
	 * @throws CoreException
	 */
	abstract protected String generateCode(IProgressMonitor monitor) throws CoreException;
	
}

Lines 13-18 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/AutomaticDependencyUpdater.java (-2 / +14 lines)
13	package org.eclipse.hyades.test.tools.core.internal.common.codegen;	13	package org.eclipse.hyades.test.tools.core.internal.common.codegen;
14		14
15	import java.util.Collection;	15	import java.util.Collection;
		16	import java.util.Collections;
16	import java.util.HashSet;	17	import java.util.HashSet;
17	import java.util.Iterator;	18	import java.util.Iterator;
18		19
Lines 52-59 Link Here
52	requiredProjects.add(project);	53	requiredProjects.add(project);
53	}	54	}
54		55
55	public void adjustProject(IProject project, IProgressMonitor monitor) throws CoreException {	56	private IProjectDependencyUpdater createDelegate(IProject project) {
56	if (requiredPluginJars == null && requiredProjects == null) return;
57	IProjectDependencyUpdater delegate;	57	IProjectDependencyUpdater delegate;
58	if (PDEProjectUtil.isStrictPluginProject(project)) {	58	if (PDEProjectUtil.isStrictPluginProject(project)) {
59	delegate = new PluginProjectDependencyUpdater();	59	delegate = new PluginProjectDependencyUpdater();
Lines 71-77 Link Here
71	delegate.addRequiredProject((IProject)it.next());	71	delegate.addRequiredProject((IProject)it.next());
72	}	72	}
73	}	73	}
		74	return delegate;
		75	}
		76
		77	public void adjustProject(IProject project, IProgressMonitor monitor) throws CoreException {
		78	if (requiredPluginJars == null && requiredProjects == null) return;
		79	IProjectDependencyUpdater delegate = createDelegate(project);
74	delegate.adjustProject(project, monitor);	80	delegate.adjustProject(project, monitor);
75	}	81	}
76		82
		83	public Collection previewAdjustProject(IProject project) {
		84	if (requiredPluginJars == null && requiredProjects == null) return Collections.EMPTY_SET;
		85	IProjectDependencyUpdater delegate = createDelegate(project);
		86	return delegate.previewAdjustProject(project);
		87	}
		88
77	}	89	}

Lines 4-10 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/codegen/GenTestSuiteConstructor.java (-1 / +1 lines)
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: GenTestSuiteConstructor.java,v 1.2 2006/07/29 01:57:42 sschneid Exp $	7	* $Id$
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* IBM Corporation - initial API and implementation	10	* IBM Corporation - initial API and implementation

Lines 4-10 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/codegen/GenSuiteMethod.java (-1 / +1 lines)
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: GenSuiteMethod.java,v 1.10 2006/07/29 21:36:45 sschneid Exp $	7	* $Id$
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* IBM Corporation - initial API and implementation	10	* IBM Corporation - initial API and implementation




 **********************************************************************/
package org.eclipse.hyades.test.tools.core.internal.java.codegen;

import java.io.ByteArrayInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.hyades.models.common.facades.behavioral.ITestCase;
import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.test.core.util.EMFUtil;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.ASTHelper;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.DelegateProjectDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.IProjectDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.ImportManager;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.JavaGenerator;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.AssociateModelSourceChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.CompilationUnitChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.PotentialChange;
import org.eclipse.hyades.test.tools.core.internal.java.JavaMessages;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jface.text.Document;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.NullChange;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.TextEdit;

/**
 * JUnit code generator and code updater. This generator synchronizes the model behavior with
 * the static suite() method, and matches each test case with a test method.
 * This concrete implementation handles code generation and code update for JUnit and
 * JUnit Plugin types.
 * <p>If you do not need code synchronization, consider implementing {@link JavaGenerator}.</p>
 * @author marcelop, jcanches
 * @since 1.0.2
 */
public class JUnitGenerator extends JavaGenerator {
	
	private String superclassName;
	private boolean destructiveChangeFound;

	public JUnitGenerator(ITestSuite testSuite, IProjectDependencyUpdater updater) {
		super(testSuite, new JUnitProjectDependencyUpdater(updater, !testSuite.getImplementor().isExternalImplementor()));
	}
	
	public JUnitGenerator(ITestSuite testSuite, IProjectDependencyUpdater updater, String superclassName) {
		this(testSuite, updater);
		this.superclassName = superclassName;
	}
	
	/**
	 * @see org.eclipse.hyades.test.common.internal.codegen.Generator#generateFile(org.eclipse.hyades.models.common.facades.behavioral.ITestSuite, org.eclipse.core.resources.IFile, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected String generateCode(IProgressMonitor monitor) throws CoreException {
	throws Exception
	{
		Helper helper = new Helper();
		try {
			if (this.superclassName != null) {
				helper.setSuperclassName(this.superclassName);
			}
			ITestSuite testSuite = getTestSuite();
			computeTestMethodNames(testSuite, testSuite.getImplementor().isExternalImplementor(), helper);
			GenTestSuite generator = new GenTestSuite();
			return Helper.formatContent(generator.generate(testSuite, helper));
		} finally {
			helper.dispose();
		}
		computeTestMethodNames(testSuite, testSuite.getImplementor().isExternalImplementor(), helper);
		GenTestSuite generator = new GenTestSuite();
		String content = Helper.formatContent(generator.generate(testSuite, helper));
		// use UTF-8 encoding - bugzilla_88029 running test with non-ASCII characters.
		file.create(new ByteArrayInputStream(content.getBytes(CHARSET_UTF8)), true, monitor);
		file.setCharset(CHARSET_UTF8, monitor);
		helper.dispose();
		// Associate the java file to the testsuite file
		associateJavaFileToTestSuite(file, testSuite);
	}
	
	protected Change createPostCodegenerationChange(IProgressMonitor monitor) throws CoreException {
		PotentialChange change = new AssociateModelSourceChange(getFileHandle(getTestSuite()), getTestSuite());
		if (change.hasEffect()) {
			return change;
		}
		return new NullChange();
	}

	protected Change createSourceUpdateChange(IFile file, SubProgressMonitor monitor) throws CoreException {
		monitor.beginTask("", 4); //$NON-NLS-1$
		try {
			ASTParser parser = ASTParser.newParser(AST.JLS3); // TODO Compute the argument
			ITestSuite testSuite = getTestSuite();
			ICompilationUnit compilationUnit = JavaCore.createCompilationUnitFrom(file);
			
			Helper helper = new Helper();
			String packageName = helper.getPackageName(testSuite);
			helper.setImportManager(new ImportManager(packageName));
			try {
				// Parse the source code
				destructiveChangeFound = false;
				Document doc = new Document(compilationUnit.getBuffer().getContents());
				parser.setSource(doc.get().toCharArray());
				CompilationUnit cu = (CompilationUnit) parser.createAST(new SubProgressMonitor(monitor, 1));
				cu.recordModifications();
				TypeDeclaration mainType = ASTHelper.getMainType(cu);
				if (mainType == null) {
					// TODO Error
					return new NullChange();
				}
				
				// Modify the AST tree
				updateTestMethods(testSuite, mainType, helper, new SubProgressMonitor(monitor, 1));
				// The generation of suite() must be performed after the test methods update
				// because the methods names might change during the update.
				if (!testSuite.getImplementor().isExternalImplementor()) {
					updateSuiteMethod(testSuite, mainType, helper);
					checkConstructor(mainType, helper);
					checkSuperType(mainType, helper);
				}
				monitor.worked(1);
				// Emit to AST the imports that are newly required by the updated code
				helper.emitSortedImports(cu);
				
				// Compute the resulting document and save it
				TextEdit edit = cu.rewrite(doc, /*options*/null);
				if (edit.getChildrenSize() != 0) {
					CompilationUnitChange change = new CompilationUnitChange(JavaMessages.UPDATE_JUNIT_CODE, compilationUnit, destructiveChangeFound);
					change.setEdit(edit);
					return change;
				}
			} catch (JavaModelException e) {
				CorePlugin.logError(e);
			} catch (MalformedTreeException e) {
				CorePlugin.logError(e);
			} finally {
				helper.dispose();
			}
		} finally {
			monitor.done();
		}
		return new NullChange();
	}

	protected void checkSuperType(TypeDeclaration mainType, Helper helper) {
		boolean doIt = false;
		Type superclassType = mainType.getSuperclassType();
		if (superclassType == null) {
			doIt = true;
		}
		
		if (superclassType.isSimpleType()) {
			SimpleType st = (SimpleType)superclassType;
			Name supertypeName = ASTHelper.resolveName((CompilationUnit)mainType.getParent(), st.getName());
			if (supertypeName != null && !Helper.HYADES_TEST_CASE_CLASS_NAME.equals(supertypeName.getFullyQualifiedName())) {
				doIt = true;
			}
		}
		if (doIt) {
			destructiveChangeFound = true;
			helper.addImport(Helper.HYADES_TEST_CASE_CLASS_NAME);
			Name newName = mainType.getAST().newName(helper.getImportedName(Helper.HYADES_TEST_CASE_CLASS_NAME));
			if (superclassType == null) {
				superclassType = mainType.getAST().newSimpleType(newName);
				mainType.setSuperclassType(superclassType);
			} else {
				((SimpleType)superclassType).setName(newName);
			}
		}
	}
	
	/**
	 * Update the content of the suite() method for the specified class,
	 * with the behavior of the specified test suite.

	 * the method if it does not exist.
	 * @throws JavaModelException 
	 */
	protected void updateSuiteMethod(ITestSuite testSuite, TypeDeclaration mainType, Helper helper) throws JavaModelException {
		// Compute the suite() method body
		GenSuiteMethod generator = new GenSuiteMethod();
		String content = generator.generate(testSuite, helper);
		MethodDeclaration newSuiteMethod = ASTHelper.parseMethod(mainType.getAST(), content);
		
		// Compute the existing suite() method index and removes it if it exists
		MethodDeclaration suiteMethod = ASTHelper.findMethodWithNoParameter(mainType, "suite"); //$NON-NLS-1$
		int index;
		if (suiteMethod == null) {
			index = ASTHelper.getFirstMethodIndex(mainType);
			if (index < methods.length) {
				sibling = methods[index];
			}
		} else {
			ITestSuite previousVersion = getRepositoryTestSuite();
			if (previousVersion != null && previousVersion.getImplementor().isExternalImplementor()) {
				destructiveChangeFound = true;
			}
			index = mainType.bodyDeclarations().indexOf(suiteMethod);
			mainType.bodyDeclarations().remove(index);
		}
		
		// Inserts the new MethodDeclaration at the right position
		if (index == -1) {
			mainType.bodyDeclarations().add(newSuiteMethod);
		} else {
			mainType.bodyDeclarations().add(index, newSuiteMethod);
		}
		mainClass.createMethod(Helper.formatContent(content, 0), sibling, /*force*/true, new NullProgressMonitor());
	}
	
	/**

	 * @param helper
	 * @throws JavaModelException 
	 */
	protected void checkConstructor(TypeDeclaration mainType, Helper helper) throws JavaModelException {
		MethodDeclaration pattern = mainType.getAST().newMethodDeclaration();
		pattern.setName(mainType.getAST().newSimpleName(mainType.getName().getIdentifier()));
		SingleVariableDeclaration svd = mainType.getAST().newSingleVariableDeclaration();
		svd.setType(mainType.getAST().newSimpleType(mainType.getAST().newSimpleName("String"))); //$NON-NLS-1$
		pattern.parameters().add(svd);
		
		MethodDeclaration constructor = ASTHelper.findMethod(mainType, pattern);
		if (constructor == null) {
			GenTestSuiteConstructor generator = new GenTestSuiteConstructor();
			String contents = generator.generate(mainType.getName().getIdentifier(), helper);
			constructor = ASTHelper.parseMethod(mainType.getAST(), contents);
			int index = ASTHelper.getFirstMethodIndex(mainType);
			if (index == -1) {
				mainType.bodyDeclarations().add(constructor);
			} else {
				mainType.bodyDeclarations().add(index, constructor);
			}
		}
	}
	
	/**
	 * Returns whether a method is a test method.
	 * @param method
	 * @return
	 */
	public static boolean isTestMethod(MethodDeclaration method) {
		String name = method.getName().getIdentifier();
		return name.startsWith("test") && method.parameters().size() == 0; //$NON-NLS-1$
	}
	
	/**

		String[] types = method.getParameterTypes();
		return name.startsWith("test") && types.length == 0; //$NON-NLS-1$
	}

	/**
	 * Update the list of test methods in the specified class, so that the list of
	 * test methods matches the list of test cases of the specified test suite.

	 * @param helper
	 * @throws JavaModelException
	 */
	protected void updateTestMethods(ITestSuite testSuite, TypeDeclaration mainType, Helper helper, IProgressMonitor monitor) throws JavaModelException {
		MethodDeclaration[] methods = mainType.getMethods();
		monitor.beginTask("", methods.length + testSuite.getITestCases().size()); //$NON-NLS-1$
		try {
			List usedTestMethods = new ArrayList(methods.length);

					actualMethodName = computedMethodName;
					Helper.setTestMethodName(testCase, actualMethodName);
				}
				MethodDeclaration method = ASTHelper.findMethodWithNoParameter(mainType, actualMethodName);
				if (method == null) {
					method = createTestMethod(mainType, testCase, helper);
				} else {
					updateTestMethod(testCase, computedMethodName, method, helper);
					if (!computedMethodName.equals(actualMethodName)) {
						method.rename(computedMethodName, /*replace*/true, new SubProgressMonitor(monitor, 1));
						Helper.setTestMethodName(testCase, computedMethodName);
					}
				}
				usedTestMethods.add(method);
				monitor.worked(1);
			}
			// 2) Remove unused test methods
			for (int i = 0; i < methods.length; i++) {
				if (isTestMethod(methods[i]) && !usedTestMethods.contains(methods[i])) {
					destructiveChangeFound = true;
					mainType.bodyDeclarations().remove(methods[i]);
				}
				monitor.worked(1);
			}

			monitor.done();
		}
	}
	
	protected void updateTestMethod(ITestCase testCase, String newName, MethodDeclaration method, Helper helper) {
		// Update method name if necessary
		if (!newName.equals(method.getName().getIdentifier())) {
			destructiveChangeFound = true;
			method.setName(method.getAST().newSimpleName(newName));
			Helper.setTestMethodName(testCase, newName);
		}
		// Update comments if necessary
		Javadoc javadoc = method.getJavadoc();
		if (javadoc == null) {
			javadoc = method.getAST().newJavadoc();
			method.setJavadoc(javadoc);
		}
		updateDescriptionTag(javadoc, testCase);
	}
	
	protected void updateDescriptionTag(Javadoc javadoc, ITestCase testCase) {
		TagElement oldtag = null;
		if (!javadoc.tags().isEmpty()) {
			TagElement tag = (TagElement) javadoc.tags().get(0);
			if (tag.getTagName() == null) {
				oldtag = tag;
			}
		}
		
		if (oldtag != null) {
			String sourceDescription = ASTHelper.extractDescription(oldtag);
			String modelDescription = makeJavadocDescription(testCase);
			if (!Helper.compareJavaComments(sourceDescription, modelDescription)) {
				destructiveChangeFound = true;
				javadoc.tags().remove(oldtag);
				ASTHelper.addDescriptionToJavadoc(javadoc, modelDescription);
			}
		} else {
			ASTHelper.addDescriptionToJavadoc(javadoc, makeJavadocDescription(testCase));
		}
	}
	
	public static String makeJavadocDescription(ITestCase testCase) {
		StringBuffer buf = new StringBuffer();
		buf.append(testCase.getName());
		if (testCase.getDescription() != null) {
			String descr = testCase.getDescription().trim();
			if (descr.length() > 0) {
				buf.append("\r\n"); //$NON-NLS-1$
				buf.append(descr);
			}
		}
		return buf.toString();
	}

	/**
	 * Creates a test method for the specified test case.
	 * @param mainClass
	 * @param testCase
	 * @param helper
	 * @throws JavaModelException 
	 */
	protected MethodDeclaration createTestMethod(TypeDeclaration mainType, ITestCase testCase, Helper helper) throws JavaModelException {
		GenTestMethod generator = new GenTestMethod();
		String content = generator.generate(testCase, helper);
		MethodDeclaration method = ASTHelper.parseMethod(mainType.getAST(), content);
		mainType.bodyDeclarations().add(method);
		return method;
	}
	
	public static class JUnitProjectDependencyUpdater extends DelegateProjectDependencyUpdater {

		public JUnitProjectDependencyUpdater(IProjectDependencyUpdater delegate, boolean isModelBehavior) {
			super(delegate);
			addRequiredPlugin("org.junit", "junit.jar"); //$NON-NLS-1$ //$NON-NLS-2$
			if (isModelBehavior) {
				addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$
				addRequiredPlugin(CorePlugin.getID(), "java.runner.jar"); //$NON-NLS-1$
					// Also add the JUnit builder to the test suite's project (the source file
					// and the test suite usually are under the same project, but this is not
					// mandatory).
					JUnitProjectBuilder.installBuilder(testSuiteFile.getProject());
					// Record the link from the java file to the testsuite file
					JUnitModelUpdater.associateTestSuiteToJUnitSourceFile(
							javaFile, testSuiteFile);
				}
			}
		} catch (Throwable t) {
			CorePlugin.logError(t);
		}

	}
	
}

Lines 4-10 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/codegen/GenTestSuite.java (-1 / +1 lines)
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: GenTestSuite.java,v 1.11 2006/07/29 01:57:42 sschneid Exp $	7	* $Id$
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* IBM Corporation - initial API and implementation	10	* IBM Corporation - initial API and implementation

Lines 4-10 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/codegen/GenTestMethod.java (-1 / +1 lines)
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: GenTestMethod.java,v 1.9 2006/07/29 21:36:45 sschneid Exp $	7	* $Id$
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* IBM Corporation - initial API and implementation	10	* IBM Corporation - initial API and implementation




 **********************************************************************/
package org.eclipse.hyades.test.tools.core.internal.manual.codegen;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.Generator;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;

 * @author marcelop
 * @since 1.0.2
 */
public class ManualGenerator extends Generator
extends Generator
{

	public ManualGenerator(ITestSuite testSuite) {
		super(testSuite);
	}

	/**
	 * @see org.eclipse.hyades.test.common.internal.codegen.Generator#generateFile(org.eclipse.hyades.models.common.facades.behavioral.ITestSuite, org.eclipse.core.resources.IFile, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected String generateCode(IProgressMonitor monitor) throws CoreException {
		return generateScript(getTestSuite());
	{
		// bugzilla_93098 specifically use UTF-8 when generating test file to work for multi-byte characters. 
		file.create(new ByteArrayInputStream(generateScript(testSuite).getBytes(CHARSET_UTF8)), true, monitor);
		file.setCharset(CHARSET_UTF8, monitor);
	}
	
	public static String generateScript(ITestSuite testSuite)

		GenTestSuite genTestSuite = new GenTestSuite();
		String script = genTestSuite.generate(testSuite, new Helper());
		
		String extraChars = "\t\t" + genTestSuite.NL; //$NON-NLS-1$
		if(script.startsWith(extraChars))
			script = script.substring(extraChars.length());
		
		return script;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.hyades.test.tools.ui.common.internal.codegen.Generator#updateFile(org.eclipse.hyades.models.common.facades.behavioral.ITestSuite, org.eclipse.core.resources.IFile, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void updateFile(ITestSuite testSuite, IFile file, IProgressMonitor monitor) throws Exception {
		// The script is not expected to be edited: update = generate
		generateFile(testSuite, file, monitor);
		
	}
}

Lines 4-10 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/manual/codegen/GenTestSuite.java (-1 / +1 lines)
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: GenTestSuite.java,v 1.11 2006/07/29 01:57:42 sschneid Exp $	7	* $Id$
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* IBM - Initial API and implementation	10	* IBM - Initial API and implementation

Lines 45-50 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/modelsync/JUnitModelUpdater.java (-10 / +49 lines)
45	import org.eclipse.hyades.test.tools.core.CorePlugin;	45	import org.eclipse.hyades.test.tools.core.CorePlugin;
46	import org.eclipse.hyades.test.tools.core.common.TestCommon;	46	import org.eclipse.hyades.test.tools.core.common.TestCommon;
47	import org.eclipse.hyades.test.tools.core.common.util.TestCommonUtil;	47	import org.eclipse.hyades.test.tools.core.common.util.TestCommonUtil;
		48	import org.eclipse.hyades.test.tools.core.internal.common.codegen.ASTHelper;
48	import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;	49	import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;
49	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;	50	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;
50	import org.eclipse.hyades.test.tools.core.java.JUnitTestSuiteFacade;	51	import org.eclipse.hyades.test.tools.core.java.JUnitTestSuiteFacade;
Lines 52-57 Link Here
52	import org.eclipse.jdt.core.IMethod;	53	import org.eclipse.jdt.core.IMethod;
53	import org.eclipse.jdt.core.IType;	54	import org.eclipse.jdt.core.IType;
54	import org.eclipse.jdt.core.JavaCore;	55	import org.eclipse.jdt.core.JavaCore;
		56	import org.eclipse.jdt.core.JavaModelException;
		57	import org.eclipse.jdt.core.dom.TagElement;
55		58
56	/**	59	/**
57	* This class provides methods for creating/updating a JUnit TestSuite model	60	* This class provides methods for creating/updating a JUnit TestSuite model
Lines 61-67 Link Here
61	*/	64	*/
62	public class JUnitModelUpdater {	65	public class JUnitModelUpdater {
63		66
64	private final static String TPTP_JUNIT_TEST_MARKER = "org.eclipse.hyades.test.tools.junit"; //$NON-NLS-1$	67	private final static String TPTP_JUNIT_TEST_MARKER = "org.eclipse.hyades.test.tools.core.junit"; //$NON-NLS-1$
65	private final static String TPTP_JUNIT_DEFINITION_ATTRIBUTE = "definition"; //$NON-NLS-1$	68	private final static String TPTP_JUNIT_DEFINITION_ATTRIBUTE = "definition"; //$NON-NLS-1$
66		69
67	/**	70	/**
Lines 106-111 Link Here
106	changed = true;	109	changed = true;
107	}	110	}
108	usedTestCases.add(testCase);	111	usedTestCases.add(testCase);
		112	if (updateTestCaseDescription(methods[i], testCase)) {
		113	changed = true;
		114	}
109	}	115	}
110	}	116	}
111	// Search for Test Cases that do not have a matching test method	117	// Search for Test Cases that do not have a matching test method
Lines 134-139 Link Here
134	return changed;	140	return changed;
135	}	141	}
136		142
		143	private static boolean updateTestCaseDescription(IMethod method, ITestCase testCase) throws JavaModelException {
		144	TagElement sourceTag = ASTHelper.getJavadocDescription(method);
		145	if (sourceTag == null) {
		146	if (testCase.getDescription() != null && testCase.getDescription().length() > 0) {
		147	testCase.setDescription(null);
		148	return true;
		149	}
		150	return false;
		151	}
		152
		153	String sourceDescription = ASTHelper.extractDescription(sourceTag);
		154	if (sourceDescription.startsWith(testCase.getName())) {
		155	sourceDescription = sourceDescription.substring(testCase.getName().length());
		156	if (sourceDescription.startsWith("\n")) sourceDescription = sourceDescription.substring("\n".length()); //$NON-NLS-1$//$NON-NLS-2$
		157	}
		158
		159	String tcDescription = testCase.getDescription();
		160	if (tcDescription == null) tcDescription = ""; //$NON-NLS-1$
		161	if (!Helper.compareJavaComments(sourceDescription, tcDescription)) {
		162	testCase.setDescription(sourceDescription.trim());
		163	return true;
		164	}
		165	return false;
		166	}
		167
137	private static ITestCase findTestCase(ITestSuite testSuite, IMethod testMethod) {	168	private static ITestCase findTestCase(ITestSuite testSuite, IMethod testMethod) {
138	Iterator it = testSuite.getITestCases().iterator();	169	Iterator it = testSuite.getITestCases().iterator();
139	Helper helper = new Helper();	170	Helper helper = new Helper();
Lines 241-255 Link Here
241		272
242	private static IFile findTestSuiteFile(IFile javaFile) throws CoreException {	273	private static IFile findTestSuiteFile(IFile javaFile) throws CoreException {
243	// First method (typical): use the marker to find the test suite definition	274	// First method (typical): use the marker to find the test suite definition
244	IMarker[] markers = javaFile.findMarkers(TPTP_JUNIT_TEST_MARKER, /includeSubTypes/false, 0);	275	IFile file = getRegisteredTestSuiteFile(javaFile);
245	if (markers.length > 0) {	276	if (file != null) {
246	String testSuiteDefinition = markers[0].getAttribute(TPTP_JUNIT_DEFINITION_ATTRIBUTE, null);	277	return file;
247	if (testSuiteDefinition != null) {
248	IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(testSuiteDefinition));
249	if (res instanceof IFile && res.exists()) {
250	return (IFile)res;
251	}
252	}
253	}	278	}
254	// Second method: find a test suite file in the same directory, with the same name	279	// Second method: find a test suite file in the same directory, with the same name
255	IContainer container = javaFile.getParent();	280	IContainer container = javaFile.getParent();
Lines 266-271 Link Here
266	return null;	291	return null;
267	}	292	}
268		293
		294	public static IFile getRegisteredTestSuiteFile(IFile javaFile) throws CoreException {
		295	IMarker[] markers = javaFile.findMarkers(TPTP_JUNIT_TEST_MARKER, /includeSubTypes/false, 0);
		296	if (markers.length > 0) {
		297	String testSuiteDefinition = markers[0].getAttribute(TPTP_JUNIT_DEFINITION_ATTRIBUTE, null);
		298	if (testSuiteDefinition != null) {
		299	IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(new Path(testSuiteDefinition));
		300	if (res instanceof IFile && res.exists()) {
		301	return (IFile)res;
		302	}
		303	}
		304	}
		305	return null;
		306	}
		307
269	/**	308	/**
270	* Marks the specified junit source file as being associated to a TPTP JUnit test. This method	309	* Marks the specified junit source file as being associated to a TPTP JUnit test. This method
271	* does not perform any workspace operation if the association is already up-to-date.	310	* does not perform any workspace operation if the association is already up-to-date.




		d.setBuildSpec(newCommands); 
		project.setDescription(d, null);
	}
	
	public static boolean isBuilderInstalled(IProject project) throws CoreException {
		IProjectDescription d = project.getDescription();
		ICommand[] buildSpec = d.getBuildSpec();
		int found = 0;
		for (int i = 0; i < buildSpec.length; i++) {
			if (buildSpec[i].getBuilderName().equals(BUILDER_ID)) {
				return true;
			}
		}
		return false;
	}

}

Lines 26-29 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/JavaMessages.java (+1 lines)
26	}	26	}
27		27
28	public static String BUILDER_LINK_TASK;	28	public static String BUILDER_LINK_TASK;
		29	public static String UPDATE_JUNIT_CODE;
29	}	30	}

Lines 14-16 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/messages.properties (+1 lines)
14	# NLS_ENCODING=UTF-8	14	# NLS_ENCODING=UTF-8
15		15
16	BUILDER_LINK_TASK=Linking Test Suites to source code	16	BUILDER_LINK_TASK=Linking Test Suites to source code
		17	UPDATE_JUNIT_CODE=Update JUnit code




 org.eclipse.tptp.test.manual.runner.ui.internal.util
Require-Bundle: org.eclipse.hyades.test.core;bundle-version="[4.2.0,5.0.0)",
 org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
 org.eclipse.jface.text;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.jdt.core;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
 org.eclipse.tptp.platform.models;bundle-version="[4.2.0,5.0.0)",
 org.eclipse.hyades.execution;bundle-version="[4.2.0,5.0.0)",
 org.eclipse.hyades.logging.core;bundle-version="[4.2.0,5.0.0)",
 com.ibm.icu;bundle-version="[3.4.3,4.0.0)",
 org.eclipse.debug.core;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
 org.eclipse.pde.core;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.ltk.core.refactoring;bundle-version="[3.2.0,4.0.0)";visibility:=reexport,
 org.eclipse.ui;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
 org.junit;bundle-version="[3.8.1,4.0.0)"
Eclipse-LazyStart: true

Lines 63-70 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/manual/launch/RunHandler.java (-2 / +2 lines)
63	if(testScript == null)	63	if(testScript == null)
64	return null;	64	return null;
65		65
66	testScript = StringUtil.replace(testScript, "\r", "");	66	testScript = StringUtil.replace(testScript, "\r", ""); //$NON-NLS-1$ //$NON-NLS-2$
67	return StringUtil.replace(testScript, "\n", "");	67	return StringUtil.replace(testScript, "\n", ""); //$NON-NLS-1$ //$NON-NLS-2$
68	}	68	}
69		69
70	/* (non-Javadoc)	70	/* (non-Javadoc)





import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.jar.JarFile;

		}
	}

	public Collection previewAdjustProject(IProject project) {
		IPluginModelBase pluginModel = findProjectPluginModel(project);
		if (pluginModel != null) {
			HashSet result = new HashSet();
			IPluginBase plugin = pluginModel.getPluginBase(/*CreateIfMissing*/false);
			Iterator it = requiredPlugins.iterator();
			boolean changed = false;
			while (it.hasNext()) {
				String pluginId = (String) it.next();
				if (findPluginImport(plugin, pluginId) == null) {
					result.add(pluginId);
				}
			}
			return result;
		}
		return Collections.EMPTY_SET;
	}


}

Lines 284-288 Link Here

(-)plugin.xml (+7 lines)
284	point="org.eclipse.hyades.execution.service">	284	point="org.eclipse.hyades.execution.service">
285	<service class="org.eclipse.hyades.test.tools.core.services.AgentControllerVerificationService"/>	285	<service class="org.eclipse.hyades.test.tools.core.services.AgentControllerVerificationService"/>
286	</extension>	286	</extension>
		287	<extension
		288	id="junit"
		289	name="TPTP JUnit source metadata"
		290	point="org.eclipse.core.resources.markers">
		291	<persistent value="true"/>
		292	<attribute name="definition"/>
		293	</extension>
287		294
288	</plugin>	295	</plugin>




/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Changes that moves a compilation unit (to a new package and/or a new name).
 * @author jcanches
 * @since 4.3
 */
public class MoveCompilationUnitChange extends Change {

	private boolean fUndoable;
	private long fStampToRestore;
	private ICompilationUnit compilationUnit;
	private IPackageFragment newPackage;
	private String newName;
	private boolean isPackageChanged;
	private boolean isClassnameChanged;
	
	public MoveCompilationUnitChange(ICompilationUnit cu, IPackageFragment newPackage, String newName){
		this(cu, newPackage, newName, IResource.NULL_STAMP);
	}
	
	private MoveCompilationUnitChange(ICompilationUnit cu, IPackageFragment newPackage, String newName, long stampToRestore) {
		this.compilationUnit = cu;
		if (newPackage == null) {
			newPackage = (IPackageFragment)compilationUnit.getParent();
		} else {
			this.newPackage = newPackage;
		}
		if (newName == null) {
			this.newName = compilationUnit.getElementName();
		} else {
			this.newName = newName;
		}
		fStampToRestore= stampToRestore;
		isPackageChanged = !compilationUnit.getParent().equals(newPackage);
		isClassnameChanged = !this.newName.equals(compilationUnit.getElementName());
	}
	
	public String getName() {
		if (isPackageChanged && isClassnameChanged) {
			return NLS.bind(CommonPluginMessages.MOVE_RENAME_COMPILATION_UNIT,
					new Object[] { compilationUnit.getElementName(), getPackageName(newPackage), newName });
		}
		if (isPackageChanged) {
			return NLS.bind(CommonPluginMessages.MOVE_COMPILATION_UNIT,
					new Object[] { compilationUnit.getElementName(), getPackageName(newPackage) });
		}
		if (isClassnameChanged) {
			return NLS.bind(CommonPluginMessages.RENAME_COMPILATION_UNIT,
					new Object[] { compilationUnit.getElementName(), newName});
		}
		return "Invalid change"; //$NON-NLS-1$
	}

	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException {
		RefactoringStatus status = new RefactoringStatus();
		if (compilationUnit.isReadOnly()) {
			status.addFatalError(NLS.bind(CommonPluginMessages.E_COMP_UNIT_READ_ONLY, compilationUnit.getElementName()));
		}
		if (newPackage.getCompilationUnit(newName).exists()) {
			status.addWarning(NLS.bind(CommonPluginMessages.W_COMP_UNIT_OVERWRITE, compilationUnit.getElementName()));
		}
		return status;
	}
	
	public Change perform(IProgressMonitor pm) throws CoreException {
		// get current modification stamp
		long currentStamp= IResource.NULL_STAMP;
		IResource resource= compilationUnit.getResource();
		if (resource != null) {
			currentStamp= resource.getModificationStamp();
		}
		
		fUndoable= ! newPackage.getCompilationUnit(newName).exists();
		String oldName = compilationUnit.getElementName();
		IPackageFragment oldPackage = (IPackageFragment) compilationUnit.getParent();
		
		// perform the move and restore modification stamp
		compilationUnit.move(newPackage, null, newName, true, pm);
		ICompilationUnit moved= newPackage.getCompilationUnit(newName);
		if (fStampToRestore != IResource.NULL_STAMP) {
			IResource movedResource= moved.getResource();
			if (movedResource != null) {
				movedResource.revertModificationStamp(fStampToRestore);
			}
		}
		
		if (fUndoable) {
			return new MoveCompilationUnitChange(moved, oldPackage, oldName, currentStamp);
		} else {
			return null;
		}
	}
	
	static String getPackageName(IPackageFragment pack) {
		if (pack.isDefaultPackage())
			return CommonPluginMessages.DEFAULT_PACKAGE; 
		else
			return pack.getElementName();
	}

	public Object getModifiedElement() {
		return compilationUnit;
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// NOP
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ltk.core.refactoring.TextFileChange;

/**
 * Change that modifies the content of a compilation unit.
 * Copied from org.eclipse.jdt.internal.corext.refactoring.changes.CompilationUnitChange.
 * @author jcanches
 * @since 4.3
 */
public class CompilationUnitChange extends TextFileChange {

	private ICompilationUnit fCUnit;
	private boolean destructive;
	
	/**
	 * Creates a new <code>CompilationUnitChange</code>.
	 * 
	 * @param name the change's name mainly used to render the change in the UI
	 * @param cunit the compilation unit this text change works on
	 * @param destructive Whether this change contains destructive changes (i.e. applying it
	 * will delete some existing code)
	 */
	public CompilationUnitChange(String name, ICompilationUnit cunit, boolean destructive) {
		super(name, getFile(cunit));
		Assert.isNotNull(cunit);
		fCUnit= cunit;
		setTextType("java"); //$NON-NLS-1$
		this.destructive = destructive;
	}
	
	private static IFile getFile(ICompilationUnit cunit) {
		return (IFile) cunit.getResource();
	}
	
	/* non java-doc
	 * Method declared in IChange.
	 */
	public Object getModifiedElement(){
		return fCUnit;
	}
	
	/**
	 * Returns the compilation unit this change works on.
	 * 
	 * @return the compilation unit this change works on
	 */
	public ICompilationUnit getCompilationUnit() {
		return fCUnit;
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected IDocument acquireDocument(IProgressMonitor pm) throws CoreException {
		pm.beginTask("", 2); //$NON-NLS-1$
		fCUnit.becomeWorkingCopy(null, new SubProgressMonitor(pm, 1));
		return super.acquireDocument(new SubProgressMonitor(pm, 1));
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected void releaseDocument(IDocument document, IProgressMonitor pm) throws CoreException {
		super.releaseDocument(document, pm);
		try {
			fCUnit.discardWorkingCopy();
		} finally {
			if (!isDocumentAcquired()) {
				if (fCUnit.isWorkingCopy())
					fCUnit.reconcile(
							ICompilationUnit.NO_AST, 
							false /* don't force problem detection */, 
							null /* use primary owner */, 
							null /* no progress monitor */);

				else
					fCUnit.makeConsistent(pm);
			}
		}
	}
	
//	/**
//	 * {@inheritDoc}
//	 */
//	protected Change createUndoChange(UndoEdit edit, ContentStamp stampToRestore) {
//		try {
//			return new UndoCompilationUnitChange(getName(), fCUnit, edit, stampToRestore, getSaveMode());
//		} catch (CoreException e) {
//			JavaPlugin.log(e);
//			return null;
//		}
//	}
	
	/**
	 * {@inheritDoc}
	 */
	public Object getAdapter(Class adapter) {
		if (ICompilationUnit.class.equals(adapter))
			return fCUnit;
		return super.getAdapter(adapter);
	}
	
	public boolean isDestructive() {
		return destructive;
	}
}





/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that transforms a folder into a source folder.
 * @author jcanches
 * @since 4.3
 */
public class AdjustSourceContainerChange extends PotentialChange {

	private IContainer container;

	public AdjustSourceContainerChange(IContainer container) {
		this.container = container;
	}
	
	public Object getModifiedElement() {
		return container;
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.DEFINE_SOURCE_FOLDER, container.getFullPath().toString());
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// NOP
	}

	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,	OperationCanceledException {
		pm.beginTask("", 2); //$NON-NLS-1$
		try {
			RefactoringStatus status = new RefactoringStatus();
			if (!container.isAccessible()) {
				status.addFatalError(NLS.bind(CommonPluginMessages.RESOURCE_NOT_ACCESSIBLE, container.getFullPath().toString()));
			}
			pm.worked(1);
			IJavaProject javaProject = JavaCore.create(container.getProject());
			if (!javaProject.exists()) {
				status.addFatalError(NLS.bind(CommonPluginMessages.NOT_IN_JAVA_PROJECT, container.getFullPath().toString()));
			}
			pm.worked(1);
			return status;
		} finally {
			pm.done();
		}
	}

	public Change perform(IProgressMonitor monitor) throws CoreException {
		IJavaProject javaProject = JavaCore.create(container.getProject());
		if(container.getType() == IResource.FOLDER)
		{
			if(!javaProject.isOnClasspath(container))
			{
				IClasspathEntry entry = JavaCore.newSourceEntry(container.getFullPath());
				List entries = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
				entries.add(1, entry);
				javaProject.setRawClasspath((IClasspathEntry[])entries.toArray(new IClasspathEntry[entries.size()]), monitor);
			}
		}
		return null;
	}

	public boolean hasEffect() {
		IJavaProject javaProject = JavaCore.create(container.getProject());
		if(container.getType() == IResource.FOLDER)
		{
			return !javaProject.isOnClasspath(container);
		}
		return true;
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

/**
 * Utility dependency updater that delegates the update to a user-provided updater. Typically, a specific
 * type provider will implement this class and use it to wrap the user-provided dependency updater.
 * Mandatory dependencies can be registered in the constructor.
 * @author jcanches
 * @since 4.3
 */
public abstract class DelegateProjectDependencyUpdater implements IProjectDependencyUpdater {

	private IProjectDependencyUpdater delegate;
	
	public DelegateProjectDependencyUpdater(IProjectDependencyUpdater delegate) {
		this.delegate = delegate;
	}

	public void addRequiredPlugin(String pluginId, String jarName) {
		delegate.addRequiredPlugin(pluginId, jarName);
	}

	public void addRequiredProject(IProject project) {
		delegate.addRequiredProject(project);
	}

	public void adjustProject(IProject project, IProgressMonitor monitor) throws CoreException {
		delegate.adjustProject(project, monitor);
	}

	public Collection previewAdjustProject(IProject project) {
		return delegate.previewAdjustProject(project);
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.IProjectDependencyUpdater;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that applies a project dependency updater on a project.
 * @author jcanches
 * @since 4.3
 */
public class ProjectAdjustChange extends Change {

	private IProject project;
	private IProjectDependencyUpdater updater;
	
	public ProjectAdjustChange(IProjectDependencyUpdater updater, IProject project) {
		this.updater = updater;
		this.project = project;
	}
	
	public Object getModifiedElement() {
		return project;
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.ADJUST_CLASSPATH, project.getName());
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// NOP
	}

	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException, OperationCanceledException {
		RefactoringStatus status = new RefactoringStatus();
		if (!project.isAccessible()) {
			status.addFatalError(NLS.bind(CommonPluginMessages.PROJECT_NOT_ACCESSIBLE, project.getName()));
		}
		return status;
	}

	public Change perform(IProgressMonitor monitor) throws CoreException {
		updater.adjustProject(project, monitor);
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that creates a java package.
 * @author jcanches
 * @since 4.3
 */
public class CreatePackageFragmentChange extends PotentialChange {

	private IPackageFragmentRoot sourceFolder;
	private String packageName;

	public CreatePackageFragmentChange(IPackageFragmentRoot sourceFolder, String packageName) {
		this.sourceFolder = sourceFolder;
		this.packageName = packageName;
	}
	
	public boolean hasEffect() {
		return !sourceFolder.getPackageFragment(packageName).exists();
	}

	public Object getModifiedElement() {
		return sourceFolder;
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.CREATE_PACKAGE, packageName); 
	}

	public void initializeValidationData(IProgressMonitor monitor) {
		// NOP
	}

	public RefactoringStatus isValid(IProgressMonitor monitor) throws CoreException, OperationCanceledException {
		RefactoringStatus status = new RefactoringStatus();
		if (!sourceFolder.exists()) {
			status.addFatalError(CommonPluginMessages.NO_SOURCE_FOLDER);
		} else if (sourceFolder.getResource().getType() != IResource.FOLDER) {
			status.addFatalError(CommonPluginMessages.NOT_A_SOURCE_FOLDER);
		}
		return status;
	}

	public Change perform(IProgressMonitor monitor) throws CoreException {
		sourceFolder.createPackageFragment(packageName, true, monitor);
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen;

import java.util.Iterator;

import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper.LineIterator;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTMatcher;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.MemberRef;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodRef;
import org.eclipse.jdt.core.dom.MethodRefParameter;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.TextElement;
import org.eclipse.jdt.core.dom.TypeDeclaration;

/**
 * Utilities for manipulating AST trees.
 * @author jcanches
 * @since 4.3
 */
public class ASTHelper {

	/**
	 * Resolves a name to a qualified name, in the context of a given compilation unit,
	 * by looking at the imports.
	 */
	public static Name resolveName(CompilationUnit cu, Name name) {
		if (name.isSimpleName()) {
			SimpleName simpleName = (SimpleName)name;
			Iterator it = cu.imports().iterator();
			while (it.hasNext()) {
				ImportDeclaration id = (ImportDeclaration) it.next();
				if (matchName(simpleName, id.getName())) return id.getName(); 
			}
			return null;
		}
		return name;
	}

	private static boolean matchName(SimpleName simple, Name complete) {
		SimpleName unqualifiedName = null;
		if (complete.isSimpleName()) {
			unqualifiedName = (SimpleName)complete;
		}
		if (complete.isQualifiedName()) {
			QualifiedName qn = (QualifiedName) complete;
			unqualifiedName = qn.getName();
		}
		if (unqualifiedName != null) {
			return simple.getIdentifier().equals(unqualifiedName.getIdentifier());
		}
		return false;
	}
	
	/**
	 * Determines whether a compilation unit has a given import.
	 */
	public static boolean hasImport(CompilationUnit cu, String qualifiedName) {
		for (Iterator it = cu.imports().iterator(); it.hasNext();) {
			ImportDeclaration id = (ImportDeclaration)it.next();
			if (qualifiedName.equals(id.getName().getFullyQualifiedName())) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Parses a method declaration and returns the resulting AST element.
	 * @param ast The AST that the result must belong to.
	 * @param methodDeclaration A method declaration (as a string).
	 * @return An AST MethodDeclaration object.
	 */
	public static MethodDeclaration parseMethod(AST ast, String methodDeclaration) {
		ASTParser parser = ASTParser.newParser(ast.apiLevel());
		parser.setSource(methodDeclaration.toCharArray());
		parser.setKind(ASTParser.K_CLASS_BODY_DECLARATIONS);
		TypeDeclaration localType = (TypeDeclaration) parser.createAST(/*progress monitor*/null);
		MethodDeclaration method = (MethodDeclaration) localType.bodyDeclarations().get(0);
		// The resulting method must be cloned to the proper AST owner
		return (MethodDeclaration) ASTNode.copySubtree(ast, method);
	}
	
	/**
	 * Returns the method with 0 parameters matching the given name in the given type.
	 * @param type
	 * @param name
	 * @return
	 */
	public static MethodDeclaration findMethodWithNoParameter(TypeDeclaration type, String name) {
		MethodDeclaration[] methods = type.getMethods();
		for (int i = 0; i < methods.length; i++) {
			if (name.equals(methods[i].getName().getIdentifier()) && methods[i].parameters().isEmpty()) {
				return methods[i];
			}
		}
		return null;
	}
	
	/**
	 * Returns the method matching the name and the parameter types of a pattern.
	 * Return type, nor parameter names are taken into account.
	 * @param type The type where method is searched
	 * @param pattern A pattern. Only method name, and parameters types are taken into account.
	 * @return The method within <code>type</code> that matches pattern, or <code>null</code>
	 * if not found.
	 */
	public static MethodDeclaration findMethod(TypeDeclaration type, MethodDeclaration pattern) {
		MethodDeclaration[] methods = type.getMethods();
		for (int i = 0; i < methods.length; i++) {
			if (pattern.getName().getIdentifier().equals(methods[i].getName().getIdentifier()) && pattern.parameters().size() == methods[i].parameters().size()) {
				// Same name, same number of formal parameters:
				for (Iterator it1 = pattern.parameters().iterator(),
					          it2 = methods[i].parameters().iterator(); it1.hasNext();) {
					SingleVariableDeclaration patDecl = (SingleVariableDeclaration)it1.next();
					SingleVariableDeclaration matDecl = (SingleVariableDeclaration)it2.next();
					if (!patDecl.getType().subtreeMatch(new ASTMatcher(), matDecl.getType())) {
						break;
					}
				}
				return methods[i];
			}
		}
		return null;
	}
	
	/**
	 * Returns the index, among all the type members, of the first method within a
	 * type declaration.
	 * @param type A type declaration.
	 * @return The index of the first method, or -1 if there is no method within <code>type</code>.
	 */
	public static int getFirstMethodIndex(TypeDeclaration type) {
		int cpt;
		Iterator it;
		for (cpt = 0, it = type.bodyDeclarations().iterator(); it.hasNext(); cpt++) {
			BodyDeclaration bd = (BodyDeclaration)it.next();
			if (bd instanceof MethodDeclaration) {
				return cpt;
			}
		}
		return -1;
	}
	
	/**
	 * Returns the only public, first-level type declaration found in a compilation unit.
	 * @param cu A Compilation Unit.
	 * @return The "main" type, or <code>null</code> if no such type exists.
	 */
	public static TypeDeclaration getMainType(CompilationUnit cu) {
		for (Iterator it = cu.types().iterator(); it.hasNext(); ) {
			AbstractTypeDeclaration atd = (AbstractTypeDeclaration)it.next();
			if (atd.isPackageMemberTypeDeclaration()
				&& (atd.getModifiers() & Modifier.PUBLIC) != 0
				&& atd instanceof TypeDeclaration) {
				return (TypeDeclaration)atd;
			}
		}
		return null;
	}
	
	private static TagElement getJavadocDescription (String methodSource) {
		ASTParser parser = ASTParser.newParser(AST.JLS3);
		parser.setKind(ASTParser.K_CLASS_BODY_DECLARATIONS);
		parser.setSource(methodSource.toCharArray());
		TypeDeclaration type = (TypeDeclaration) parser.createAST(null);
		MethodDeclaration md = (MethodDeclaration) type.bodyDeclarations().get(0);
		Javadoc javadoc = md.getJavadoc();
		if (javadoc != null && javadoc.tags().size() > 0) {
			TagElement tag = (TagElement) javadoc.tags().get(0);
			if (tag.getTagName() == null) {
				return tag;
			}
		}
		return null;
	}
	
	public static TagElement getJavadocDescription(IMethod method) throws JavaModelException {
		return getJavadocDescription(method.getSource());
	}
	
	public static TagElement parseJavadocDescription(AST ast, String javadoc) {
		String input = "/**" + javadoc + "*/void f(){}"; //$NON-NLS-1$ //$NON-NLS-2$
		TagElement tag = getJavadocDescription(input);
		return (TagElement)ASTNode.copySubtree(ast, tag);
	}
	
	public static boolean compareJavadocDescriptions(TagElement tag1, TagElement tag2) {
		return (tag1 == null && tag2 == null)
			|| (tag1 != null && tag1.subtreeMatch(new ASTMatcher(true), tag2));
	}
	
	public static String extractDescription(TagElement tag) {
		JavatagFlattener flattener = new JavatagFlattener();
		tag.accept(flattener);
		return flattener.getResult();
	}
	
	static class JavatagFlattener extends ASTVisitor {

		private StringBuffer buf = new StringBuffer();
		
		public String getResult() {
			return buf.toString();
		}
		
		public boolean visit(MemberRef node) {
			if (node.getQualifier() != null) {
				node.getQualifier().accept(this);
			}
			buf.append("#");//$NON-NLS-1$
			node.getName().accept(this);
			return false;
		}

		public boolean visit(MethodRef node) {
			if (node.getQualifier() != null) {
				node.getQualifier().accept(this);
			}
			buf.append("#");//$NON-NLS-1$
			node.getName().accept(this);
			buf.append("(");//$NON-NLS-1$
			for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
				MethodRefParameter e = (MethodRefParameter) it.next();
				e.accept(this);
				if (it.hasNext()) {
					buf.append(",");//$NON-NLS-1$
				}
			}
			buf.append(")");//$NON-NLS-1$
			return false;
		}

		public boolean visit(SimpleName node) {
			buf.append(node.getIdentifier());
			return false;
		}
		
		public boolean visit(QualifiedName node) {
			node.getQualifier().accept(this);
			buf.append(".");//$NON-NLS-1$
			node.getName().accept(this);
			return false;
		}

		public boolean visit(TagElement node) {
			if (node.isNested()) {
				// nested tags are always enclosed in braces
				buf.append("{");//$NON-NLS-1$
			}
			boolean previousRequiresWhiteSpace = false;
			if (node.getTagName() != null) {
				buf.append(node.getTagName());
				previousRequiresWhiteSpace = true;
			}
			boolean previousRequiresNewLine = false;
			for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
				ASTNode e = (ASTNode) it.next();
				// assume text elements include necessary leading and trailing whitespace
				// but Name, MemberRef, MethodRef, and nested TagElement do not include white space
				boolean currentIncludesWhiteSpace = (e instanceof TextElement);
				if (previousRequiresNewLine && currentIncludesWhiteSpace) {
					buf.append("\n");//$NON-NLS-1$
				}
				previousRequiresNewLine = currentIncludesWhiteSpace;
				// add space if required to separate
				if (previousRequiresWhiteSpace && !currentIncludesWhiteSpace) {
					buf.append(" "); //$NON-NLS-1$
				}
				e.accept(this);
				previousRequiresWhiteSpace = !currentIncludesWhiteSpace && !(e instanceof TagElement);
			}
			if (node.isNested()) {
				buf.append("}");//$NON-NLS-1$
			}
			return false;
		}

		public boolean visit(TextElement node) {
			buf.append(node.getText());
			return false;
		}
		
	}

	public static void addDescriptionToJavadoc(Javadoc javadoc, String string) {
		LineIterator it = new Helper.LineIterator(string, " \t"); //$NON-NLS-1$
		int idx = 0;
		while(it.hasNextLine()) {
			TagElement tag = javadoc.getAST().newTagElement();
			TextElement text = javadoc.getAST().newTextElement();
			text.setText(it.getNextLine());
			tag.fragments().add(text);
			javadoc.tags().add(idx++, tag);
		}
		
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.NullChange;

/**
 * Change that may be a NO-OP.
 * @author jcanches
 * @since 4.3
 */
public abstract class PotentialChange extends Change {

	/**
	 * Determines if the change would have any real effect, if it was applied.
	 * If the method returns <code>false</code>, then the effect of the change is
	 * equivalent to {@link NullChange}.
	 * @return <code>true</code> if and only if applying the change have a real effect.
	 */
	public abstract boolean hasEffect();
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.test.core.util.EMFUtil;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.JUnitModelUpdater;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.JUnitProjectBuilder;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that adds a JUnit association from a java file to a test suite model.
 * @author jcanches
 * @since 4.3
 */
public class AssociateModelSourceChange extends PotentialChange {
	
	private IFile javaFile;
	private ITestSuite testSuite;
	
	/**
	 * @param javaFile
	 * @param testSuite
	 */
	public AssociateModelSourceChange(IFile javaFile, ITestSuite testSuite) {
		this.javaFile = javaFile;
		this.testSuite = testSuite;
	}

	public Object getModifiedElement() {
		return javaFile;
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.ASSOCIATE_TEST_TO_SOURCE, new Object[] { testSuite.getName(), javaFile.getFullPath().toString() });
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// NOP
	}

	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,	OperationCanceledException {
		return new RefactoringStatus();
	}

	public Change perform(IProgressMonitor pm) throws CoreException {
		pm.beginTask("", 3); //$NON-NLS-1$
		try {
			if (testSuite instanceof EObject) {
				EObject eObject = (EObject) testSuite;
				IFile testSuiteFile = EMFUtil.getWorkspaceFile(eObject);
				if (testSuiteFile != null && testSuiteFile.exists()) {
					// Add the Junit builder to the file's project (if not already installed)
					JUnitProjectBuilder.installBuilder(javaFile.getProject());
					pm.worked(1);
					// Also add the JUnit builder to the test suite's project (the source file
					// and the test suite usually are under the same project, but this is not
					// mandatory).
					JUnitProjectBuilder.installBuilder(testSuiteFile.getProject());
					pm.worked(1);
					// Record the link from the java file to the testsuite file
					JUnitModelUpdater.associateTestSuiteToJUnitSourceFile(javaFile, testSuiteFile);
					pm.worked(1);
				}
			}
		} catch (Throwable t) {
			CorePlugin.logError(t);
		} finally {
			pm.done();
		}
		return null;
	}

	public boolean hasEffect() {
		if (!javaFile.exists()) return true;
		try {
			if (!JUnitProjectBuilder.isBuilderInstalled(javaFile.getProject())) return true;
			if (testSuite instanceof EObject) {
				EObject eObject = (EObject) testSuite;
				IFile testSuiteFile = EMFUtil.getWorkspaceFile(eObject);
				if (testSuiteFile != null && testSuiteFile.exists()) {
					if (!JUnitProjectBuilder.isBuilderInstalled(testSuiteFile.getProject())) return true;
				}
				IFile registeredTestSuiteFile = JUnitModelUpdater.getRegisteredTestSuiteFile(javaFile);
				if (registeredTestSuiteFile == null || !registeredTestSuiteFile.equals(testSuiteFile)) return true;
				return false;
			}
			return true;
		} catch (CoreException e) {
			CorePlugin.logError(e);
			return false;
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.jdt.core.IJavaModelStatusConstants;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that deletes an existing file.
 * @author jcanches
 * @since 4.3
 */
public class DeleteFileChange extends Change {

	private IFile file;
	private String fSource;
	
	public DeleteFileChange(IFile file){
		Assert.isNotNull(file, "file"); //$NON-NLS-1$
		this.file = file;
	}
	
	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException {
		RefactoringStatus status = new RefactoringStatus();
		if (!file.exists()) {
			status.addError(CommonPluginMessages.NO_FILE);
		}
		if (file.isReadOnly()) {
			status.addWarning(CommonPluginMessages.READ_ONLY_FILE);
		}
		return status;
	}
	
	public Change perform(IProgressMonitor pm) throws CoreException {
		try {
			pm.beginTask(CommonPluginMessages.DELETING_FILE, 1); 
			Assert.isNotNull(file);
			Assert.isTrue(file.exists());
			fSource= getSource(file);
			CreateFileChange undo= createUndoChange(file, file.getModificationStamp(), fSource);
			file.delete(true, true, pm);
			return undo;
		} finally {
			pm.done();
		}
	}
	
	private String getSource(IFile file) throws CoreException {
		String encoding= null;
		try {
			encoding= file.getCharset();
		} catch (CoreException ex) {
			// fall through. Take default encoding.
		}
		
		StringBuffer sb= new StringBuffer();
		BufferedReader br= null;
		InputStream in= null;
		try {
			in= file.getContents();
		    if (encoding != null)
		        br= new BufferedReader(new InputStreamReader(in, encoding));	
		    else
		        br= new BufferedReader(new InputStreamReader(in));	
			int read= 0;
			while ((read= br.read()) != -1)
				sb.append((char) read);
		} catch (IOException e){
			throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
		} finally {
			try{
				if (br != null) br.close();
				if (in != null) in.close();
			} catch (IOException e){
				throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
			}	
		}
		return sb.toString();
	}
	
	private static CreateFileChange createUndoChange(IFile file, long stampToRestore, String source) {
		String encoding;
		try {
			encoding= file.getCharset(false);
		} catch (CoreException e) {
			encoding= null;
		}
		return new CreateFileChange(file, source, encoding, stampToRestore);
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.DELETE_FILE, file.getFullPath().toString()); 
	}

	public Object getModifiedElement() {
		return file;
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// TODO Auto-generated method stub
		
	}
}





/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URI;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.jdt.core.IJavaModelStatusConstants;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that creates a text file and fills it in with an initial content.
 * @author jcanches
 * @since 4.3
 */
public class CreateFileChange extends Change {

	private IFile fFile;
	private String fSource;
	private String fEncoding;
	private boolean fExplicitEncoding;
	private long fStampToRestore;

	public CreateFileChange(IFile file, String source, String encoding) {
		this(file, source, encoding, IResource.NULL_STAMP);
	}

	public CreateFileChange(IFile file, String source, String encoding, long stampToRestore) {
		Assert.isNotNull(file, "file"); //$NON-NLS-1$
		Assert.isNotNull(source, "source"); //$NON-NLS-1$
		fFile = file;
		fSource= source;
		fEncoding= encoding;
		fExplicitEncoding= fEncoding != null;
		fStampToRestore= stampToRestore;
	}

	protected void setEncoding(String encoding, boolean explicit) {
		Assert.isNotNull(encoding, "encoding"); //$NON-NLS-1$
		fEncoding= encoding;
		fExplicitEncoding= explicit;
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.GENERATE_FILE, fFile.getFullPath().toString());
	}

	protected void setSource(String source) {
		fSource= source;
	}

	protected String getSource() {
		return fSource;
	}

	protected IFile getFile() {
		return fFile;
	}

	public Object getModifiedElement() {
		return fFile;
	}

	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException {
		RefactoringStatus status = new RefactoringStatus();
		
		URI location = fFile.getLocationURI();
		if (location == null) {
			status.addFatalError(NLS.bind(CommonPluginMessages.UNKNOWN_LOCATION, fFile.getFullPath().toString()));
			return status;
		}
		
//		IFileInfo jFile= EFS.getStore(location).fetchInfo();
//		if (jFile.exists()) {
//			status.addFatalError(Messages.format(
//				NLSChangesMessages.CreateFileChange_error_exists, 
//				file.getFullPath().toString()));
//			return status;
//		}
		return status;
	}

	public Change perform(IProgressMonitor pm) throws CoreException {

		InputStream is= null;
		try {
			pm.beginTask(CommonPluginMessages.GENERATING_FILE, 2); 

			initializeEncoding();
			/*
			if (file.exists()) {
				CompositeChange composite= new CompositeChange(getName());
				composite.add(new DeleteFileChange(file));
				composite.add(new CreateFileChange(fPath, fSource, fEncoding, fStampToRestore, fExplicitEncoding));
				pm.worked(1);
				return composite.perform(new SubProgressMonitor(pm, 1));
			} else { */
			try {
				is= new ByteArrayInputStream(fSource.getBytes(fEncoding));
				fFile.create(is, false, new SubProgressMonitor(pm, 1));
				if (fStampToRestore != IResource.NULL_STAMP) {
					fFile.revertModificationStamp(fStampToRestore);
				}
				if (fExplicitEncoding) {
					fFile.setCharset(fEncoding, new SubProgressMonitor(pm, 1));
				} else {
					pm.worked(1);
				}
				return new DeleteFileChange(fFile);
			} catch (UnsupportedEncodingException e) {
				throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
			}
		} finally {
			try {
				if (is != null)
					is.close();
			} catch (IOException ioe) {
				throw new JavaModelException(ioe, IJavaModelStatusConstants.IO_EXCEPTION);
			} finally {
				pm.done();
			}
		}
	}

	private void initializeEncoding() {
		if (fEncoding == null) {
			fExplicitEncoding= false;
			if (fFile != null) {
				try {
					if (fFile.exists()) {
						fEncoding= fFile .getCharset(false);
						if (fEncoding == null) {
							fEncoding= fFile.getCharset(true);
						} else {
							fExplicitEncoding= true;
						}
					} else {
						fEncoding= fFile.getCharset(true);
					}
				} catch (CoreException e) {
					fEncoding= ResourcesPlugin.getEncoding();
					fExplicitEncoding= true;
				}
			} else {
				fEncoding= ResourcesPlugin.getEncoding();
				fExplicitEncoding= true;
			}
		}
		Assert.isNotNull(fEncoding);
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// TODO Auto-generated method stub
		
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.hyades.models.common.util.ResourceUtil;
import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.osgi.util.NLS;

/**
 * Change that creates a container.
 * @author jcanches
 * @since 4.3
 */
public class CreateContainerChange extends PotentialChange {

	private IContainer container;

	public CreateContainerChange(IContainer container) {
		this.container = container;
	}
	
	public Object getModifiedElement() {
		return container;
	}

	public String getName() {
		return NLS.bind(CommonPluginMessages.CREATE_CONTAINER, container.getFullPath().toString());
	}

	public void initializeValidationData(IProgressMonitor pm) {
		// NOP
	}

	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException,	OperationCanceledException {
		return new RefactoringStatus();
	}

	public Change perform(IProgressMonitor monitor) throws CoreException {
		ResourceUtil.createContainer(container, monitor);
		return null;
	}

	public boolean hasEffect() {
		return !container.isAccessible();
	}

}

Lines 13-30 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/editor/JUnitEditorExtension.java (-16 / +72 lines)
13		13
14	import org.eclipse.core.resources.IResource;	14	import org.eclipse.core.resources.IResource;
15	import org.eclipse.core.resources.ResourcesPlugin;	15	import org.eclipse.core.resources.ResourcesPlugin;
		16	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.core.runtime.IProgressMonitor;	17	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.IStatus;	18	import org.eclipse.core.runtime.IStatus;
		19	import org.eclipse.core.runtime.NullProgressMonitor;
		20	import org.eclipse.core.runtime.OperationCanceledException;
18	import org.eclipse.core.runtime.Path;	21	import org.eclipse.core.runtime.Path;
		22	import org.eclipse.core.runtime.Preferences;
19	import org.eclipse.core.runtime.SubProgressMonitor;	23	import org.eclipse.core.runtime.SubProgressMonitor;
20	import org.eclipse.hyades.test.tools.core.CorePlugin;	24	import org.eclipse.hyades.test.tools.core.CorePlugin;
21	import org.eclipse.hyades.test.tools.core.internal.common.codegen.AutomaticDependencyUpdater;	25	import org.eclipse.hyades.test.tools.core.internal.common.codegen.AutomaticDependencyUpdater;
		26	import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;
22	import org.eclipse.hyades.test.tools.core.internal.common.codegen.IProjectDependencyUpdater;	27	import org.eclipse.hyades.test.tools.core.internal.common.codegen.IProjectDependencyUpdater;
23	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;	28	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;
24	import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;	29	import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
25	import org.eclipse.hyades.test.tools.ui.common.internal.editor.TestSuiteEditorExtension;	30	import org.eclipse.hyades.test.tools.ui.common.internal.editor.TestSuiteEditorExtension;
		31	import org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences.JUnitPreferences;
		32	import org.eclipse.hyades.test.tools.ui.java.internal.junit.wizard.UpdateCodeWizard;
26	import org.eclipse.hyades.test.ui.editor.form.util.WidgetFactory;	33	import org.eclipse.hyades.test.ui.editor.form.util.WidgetFactory;
27	import org.eclipse.hyades.ui.editor.IHyadesEditorPart;	34	import org.eclipse.hyades.ui.editor.IHyadesEditorPart;
		35	import org.eclipse.jface.dialogs.IDialogConstants;
		36	import org.eclipse.ltk.core.refactoring.Change;
		37	import org.eclipse.ltk.core.refactoring.Refactoring;
		38	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
		39	import org.eclipse.ltk.ui.refactoring.RefactoringWizard;
		40	import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation;
28	import org.eclipse.swt.widgets.MessageBox;	41	import org.eclipse.swt.widgets.MessageBox;
29		42
30	/**	43	/**
Lines 86-92 Link Here
86	protected void displayCodeGenerationProblem(String message) {	99	protected void displayCodeGenerationProblem(String message) {
87	MessageBox box = new MessageBox(	100	MessageBox box = new MessageBox(
88	getHyadesEditorPart().getEditorPart().getSite().getShell());	101	getHyadesEditorPart().getEditorPart().getSite().getShell());
89	box.setText("Code Generator");	102	box.setText(ToolsUiPlugin.getString("CODE_UPDATE")); //$NON-NLS-1$
90	box.setMessage(message);	103	box.setMessage(message);
91	box.open();	104	box.open();
92	}	105	}
Lines 99-105 Link Here
99	try {	112	try {
100	// Instantiate our generator	113	// Instantiate our generator
101	IProjectDependencyUpdater pUpdater = new AutomaticDependencyUpdater();	114	IProjectDependencyUpdater pUpdater = new AutomaticDependencyUpdater();
102	JUnitGenerator generator = new JUnitGenerator(pUpdater);	115	JUnitGenerator generator = new JUnitGenerator(getTestSuite(), pUpdater);
103	// bugzilla 104343: Evaluate whether the project/source folder of the	116	// bugzilla 104343: Evaluate whether the project/source folder of the
104	// test suite exist. We never force a project or source folder creation.	117	// test suite exist. We never force a project or source folder creation.
105	IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(	118	IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(
Lines 111-131 Link Here
111	// (e.g. importing or checking out the project from CVS).	124	// (e.g. importing or checking out the project from CVS).
112	displayCodeGenerationProblem(ToolsUiPlugin.getString("EDT_JUNIT_MSSING_SRCFOLDER", getTestSuite().getImplementor().getLocation())); //$NON-NLS-1$	125	displayCodeGenerationProblem(ToolsUiPlugin.getString("EDT_JUNIT_MSSING_SRCFOLDER", getTestSuite().getImplementor().getLocation())); //$NON-NLS-1$
113	} else {	126	} else {
114	// Before generating, check that everything is OK	127	// Generate the code (this operation may modify the test suite model)
115	IStatus status = generator.validate(getTestSuite());	128	if (!performChange(generator)) {
116	if (status.getSeverity() == IStatus.ERROR) {	129	throw new OperationCanceledException();
117	// Something wrong: display a message and don't generate
118	displayCodeGenerationProblem(status.getMessage());
119	} else {
120	// Make sure the classpath contains the required libraries
121	if (!getTestSuite().getImplementor().isExternalImplementor()) {
122	pUpdater.addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$
123	pUpdater.addRequiredPlugin(CorePlugin.getID(), "java.runner.jar"); //$NON-NLS-1$
124	}
125	pUpdater.addRequiredPlugin("org.junit", "junit.jar"); //$NON-NLS-1$ //$NON-NLS-2$
126	// Generate the code (this operation may modify the test suite model)
127	generator.generate(getTestSuite(), new SubProgressMonitor(monitor, 1));
128	}	130	}
		131	((JUnitForm)getTestSuiteForm()).reloadSourceInfo();
129	}	132	}
130	// Perform the save	133	// Perform the save
131	super.save(new SubProgressMonitor(monitor, 1));	134	super.save(new SubProgressMonitor(monitor, 1));
Lines 133-136 Link Here
133	monitor.done();	136	monitor.done();
134	}	137	}
135	}	138	}
		139
		140	private boolean performBatchChange(Change change) {
		141	try {
		142	change.initializeValidationData(new NullProgressMonitor());
		143	if (change.isValid(new NullProgressMonitor()).isOK()) {
		144	change.perform(new NullProgressMonitor());
		145	return true;
		146	}
		147	return false;
		148	} catch (OperationCanceledException e) {
		149	return false;
		150	} catch (CoreException e) {
		151	ToolsUiPlugin.logError(e);
		152	return false;
		153	}
		154	}
		155
		156	protected boolean performChange(Refactoring refactoring) {
		157	Preferences prefs = ToolsUiPlugin.getDefault().getPluginPreferences();
		158	int previewPref = prefs.getInt(JUnitPreferences.UPDATE_PREVIEW_MODE);
		159	boolean showWizard = previewPref != JUnitPreferences.PREVIEW_NEVER;
		160	Change change = null;
		161	try {
		162	RefactoringStatus status = refactoring.checkAllConditions(new NullProgressMonitor());
		163	if (status.hasEntries()) {
		164	// If there's something that the user should be aware of, always show the
		165	// preview.
		166	showWizard = true;
		167	} else {
		168	change = refactoring.createChange(new NullProgressMonitor());
		169	if (previewPref == JUnitPreferences.PREVIEW_IF_DESTRUCTIVE && !Helper.isDestructiveChange(change)) {
		170	showWizard = false;
		171	}
		172	}
		173	} catch (OperationCanceledException e1) {
		174	return false;
		175	} catch (CoreException e1) {
		176	ToolsUiPlugin.logError(e1);
		177	return false;
		178	}
		179	if (showWizard \|\| (change != null && !performBatchChange(change))) {
		180	UpdateCodeWizard wizard = new UpdateCodeWizard(refactoring, showWizard);
		181	wizard.setDefaultPageTitle(ToolsUiPlugin.getString("CODE_UPDATE_PREVIEW")); //$NON-NLS-1$
		182	RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wizard);
		183	try {
		184	return op.run(this.getHyadesEditorPart().getEditorPart().getEditorSite().getShell(), ToolsUiPlugin.getString("CODE_UPDATE")) == IDialogConstants.OK_ID; //$NON-NLS-1$
		185	} catch (InterruptedException e) {
		186	ToolsUiPlugin.logError(e);
		187	return false;
		188	}
		189	}
		190	return true;
		191	}
136	}	192	}

Lines 117-120 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/editor/JUnitForm.java (+4 lines)
117	super.load();	117	super.load();
118	sourceInfoSection.setInput(getTestSuite());	118	sourceInfoSection.setInput(getTestSuite());
119	}	119	}
		120
		121	public void reloadSourceInfo() {
		122	sourceInfoSection.setInput(getTestSuite());
		123	}
120	}	124	}





import java.util.Iterator;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.hyades.models.common.configuration.CFGClass;
import org.eclipse.hyades.models.common.configuration.impl.CFGInstanceImpl;
import org.eclipse.hyades.models.common.configuration.impl.Common_ConfigurationFactoryImpl;

import org.eclipse.hyades.models.common.interactions.impl.Common_Behavior_InteractionsFactoryImpl;
import org.eclipse.hyades.models.common.testprofile.TPFBehavior;
import org.eclipse.hyades.models.common.testprofile.TPFTest;
import org.eclipse.hyades.test.core.util.EMFUtil;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.JUnitModelUpdater;
import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;

import org.eclipse.hyades.test.ui.editor.form.util.WidgetFactory;
import org.eclipse.hyades.test.ui.internal.util.SpecialFieldsBidiListener;
import org.eclipse.hyades.ui.internal.util.GridDataUtil;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.SelectionDialog;


	private Button sourceFolderButton;
	private Button packageButton;
	private Button updateFromCodeButton;
	private Button openClassButton;
	
	private IImplementor implementor;
	private VerifyKeyListener verifyKeyListener;


		if(widgetFactory != null)
			sourceFolderText = widgetFactory.createStyledText(composite, SWT.FULL_SELECTION | SWT.SINGLE | SWT.LEFT_TO_RIGHT,
					ToolsUiPlugin.getString("STR_WB_SRCFOLD")); //$NON-NLS-1$
		else
			sourceFolderText =  new StyledText(composite, SWT.FULL_SELECTION | SWT.SINGLE | SWT.LEFT_TO_RIGHT | SWT.BORDER);
		sourceFolderText.setLayoutData(GridDataUtil.createHorizontalFill());

			sourceFolderButton = new Button(composite, SWT.PUSH);
			sourceFolderButton.setText(ToolsUiPlugin.getString("STR_WB_SRCFOLD_BTN")); //$NON-NLS-1$
		}
		sourceFolderButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
		sourceFolderButton.addSelectionListener(this);
		
		if(widgetFactory != null) {


		if(widgetFactory != null)
			packageText = widgetFactory.createStyledText(composite, SWT.FULL_SELECTION | SWT.SINGLE | SWT.LEFT_TO_RIGHT,
					ToolsUiPlugin.getString("STR_WB_PACK")); //$NON-NLS-1$
		else
			packageText =  new StyledText(composite, SWT.FULL_SELECTION | SWT.SINGLE | SWT.LEFT_TO_RIGHT | SWT.BORDER);
		packageText.setLayoutData(GridDataUtil.createHorizontalFill());

			packageButton.setText(ToolsUiPlugin.getString("STR_WB_PACK_BTN")); //$NON-NLS-1$
		}
		
		packageButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
		packageButton.addSelectionListener(this);

		if(widgetFactory != null) {


		if(widgetFactory != null)
			classNameText = widgetFactory.createStyledText(composite, SWT.FULL_SELECTION | SWT.SINGLE,
					ToolsUiPlugin.getString("STR_WB_CLASS")); //$NON-NLS-1$
		else
			classNameText =  new StyledText(composite, SWT.FULL_SELECTION | SWT.SINGLE | SWT.BORDER);
		classNameText.setEditable(false);
		
		if(widgetFactory != null) {
			classNameText.setLayoutData(GridDataUtil.createHorizontalFill());
			openClassButton = widgetFactory.createButton(composite, ToolsUiPlugin.getString("SOURCE_INFO_VIEWER_OPEN_CLASS"), SWT.PUSH); //$NON-NLS-1$
			openClassButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
			openClassButton.addSelectionListener(this);
		} else {
			classNameText.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false, 2, 1));
		}
		
		if (advanced) {
			if (showExternalBehavior) {
				updateFromCodeButton = widgetFactory.createButton(composite, "Refresh test methods from code", SWT.PUSH); //$NON-NLS-1$
				updateFromCodeButton.setLayoutData(new GridData(SWT.END, SWT.BEGINNING, false, false, 2, 1));
				updateFromCodeButton.addSelectionListener(this);
			}

			packageText.setEditable(false);
			classNameText.setEditable(false);
		}
		
		updateButtonsState();
	}
	
	protected void adjustTexts() {

			else
				getImplementor().setResource(pack + cls);
			
			markDirty();
		}
		updateButtonsState();
		markDirty();
	}
	
	private void updateButtonsState() {
		packageButton.setEnabled(findSourceFolder() != null);
		openClassButton.setEnabled(findCompilationUnit() != null);
	}
	
	/**

				dialog.setTitle(ToolsUiPlugin.getString("TITLE_SRC_SELECT")); //$NON-NLS-1$
				dialog.setMessage(ToolsUiPlugin.getString("STR_SRC_SELECT")); //$NON-NLS-1$
				dialog.setEmptyListMessage(ToolsUiPlugin.getString("NO_SRC")); //$NON-NLS-1$
				dialog.setInitialSelection(findSourceFolder());
				if (dialog.open() == IDialogConstants.OK_ID) {
					Object result = dialog.getFirstResult();
					String text = ""; //$NON-NLS-1$

					markDirty();
				}
			} else if (e.widget == packageButton) {
				try {
					IPackageFragmentRoot srcFolder = findSourceFolder();
					if (srcFolder != null) {
				} else {
					IJavaElement element = JavaCore.create(res);
					try {
						IPackageFragmentRoot srcFolder = null;
						String initialPackageName = getPackage();
						SelectionDialog dialog = JavaUI.createPackageDialog(packageButton.getShell(), srcFolder);
						IPackageFragment initialPackage = null;
						if (initialPackageName != null) {
							initialPackage = srcFolder.getPackageFragment(initialPackageName);
						}
						if (initialPackage != null && initialPackage.exists()) {
							dialog.setInitialSelections(new Object[] {initialPackage});
						}
						dialog.setTitle(ToolsUiPlugin.getString("TITLE_PACK_SELECT")); //$NON-NLS-1$
						dialog.setMessage(ToolsUiPlugin.getString("STR_PACK_SELECT")); //$NON-NLS-1$
						if (dialog.open() == IDialogConstants.OK_ID) {
							IPackageFragment packageFragment = (IPackageFragment)dialog.getResult()[0];
							setPackage(packageFragment.getElementName());
							markDirty();
							dialog.setTitle(ToolsUiPlugin.getString("TITLE_PACK_SELECT")); //$NON-NLS-1$
							dialog.setMessage(ToolsUiPlugin.getString("STR_PACK_SELECT")); //$NON-NLS-1$
							if (dialog.open() == IDialogConstants.OK_ID) {
								IPackageFragment packageFragment = (IPackageFragment)dialog.getResult()[0];
								setPackage(packageFragment.getElementName());
								markDirty();
							}
						}
					} catch (JavaModelException e1) {
						e.doit = false;
					}
				} catch (JavaModelException e1) {
					e.doit = false;
				}
			} else if (e.widget == externalBehavior) {
				if (externalBehavior.getSelection()) {

				} catch (CoreException e1) {
					CorePlugin.logError(e1);
				}
			} else if (e.widget == openClassButton) {
				ICompilationUnit cu = findCompilationUnit();
				if (cu != null) {
					try {
						JavaUI.openInEditor(cu);
					} catch (PartInitException e1) {
						ToolsUiPlugin.logError(e1);
						e.doit = false;
					} catch (JavaModelException e1) {
						ToolsUiPlugin.logError(e1);
						e.doit = false;
					}
				}
			}
		}
	}
	
	protected IPackageFragmentRoot findSourceFolder() {
		IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(getSourceFolder());
		if (res == null) {
			return null;
		}
		IJavaElement element = JavaCore.create(res);
		if (element == null) return null;
		try {
			IPackageFragmentRoot srcFolder = null;
			if (element instanceof IJavaProject) {
				srcFolder = ((IJavaProject)element).findPackageFragmentRoot(res.getFullPath());
			} else if (element instanceof IPackageFragmentRoot) {
				srcFolder = (IPackageFragmentRoot)element;
			}
			return srcFolder;
		} catch (JavaModelException e) {
			ToolsUiPlugin.logError(e);
			return null;
		}
	}
	
	protected IPackageFragment findPackage() {
		IPackageFragmentRoot srcFolder = findSourceFolder();
		if (srcFolder != null) {
			IPackageFragment pack = srcFolder.getPackageFragment(getPackage());
			if (pack.exists()) {
				return pack;
			}
		}
		return null;
	}
	
	protected ICompilationUnit findCompilationUnit() {
		IPackageFragment pack = findPackage();
		if (pack != null) {
			ICompilationUnit cu = pack.getCompilationUnit(getClassName() + ".java"); //$NON-NLS-1$
			if (cu.exists()) {
				return cu;
			}
		}
		return null;
	}
	
	static IBlock createBlock(IImplementor implementor) {




 *******************************************************************************/
package org.eclipse.hyades.test.tools.ui.java.internal.junit.wizard;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.AutomaticDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;
import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator.JUnitProjectDependencyUpdater;
import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.hyades.test.tools.ui.java.internal.util.ContextIds;
import org.eclipse.hyades.ui.internal.util.GridDataUtil;

	 * @return the status of the validation
	 */
	protected IStatus validateProjectClasspath() {
		Status status= new Status(IStatus.OK, ToolsUiPlugin.getID(), 1, "", null); //$NON-NLS-1$
		IPackageFragmentRoot root= getPackageFragmentRoot();
		if (root == null)
			return status;
		
		IJavaProject jp= root.getJavaProject();
		
		JUnitProjectDependencyUpdater updater = new JUnitProjectDependencyUpdater(
				new AutomaticDependencyUpdater(), isModelBehavior());
		Collection missingLibraries = updater.previewAdjustProject(jp.getProject());
		while (it.hasNext()) {
			RequiredLibrary lib = (RequiredLibrary) it.next();
			try {
				if (jp.findType(lib.testClass) == null)
					missingLibraries.add(lib);
			} catch (JavaModelException e) {
				// Let's keep quiet
			}
		}
		if (missingLibraries.isEmpty()) return status;
		
		StringBuffer librariesAsText = new StringBuffer();
		Iterator it = missingLibraries.iterator();
		while (it.hasNext()) {
			RequiredLibrary lib = (RequiredLibrary) it.next();
			if (librariesAsText.length() > 0) {
				librariesAsText.append(", "); //$NON-NLS-1$
			}
			librariesAsText.append((String)it.next());
		}
		
		if (!dontAskMissingLibsAgain) {

				message = ToolsUiPlugin.getString("SourcePage.jars_not_on_buildpath.message", librariesAsText.toString()); //$NON-NLS-1$
			}
			if (MessageDialog.openQuestion(getShell(), ToolsUiPlugin.getString("SourcePage.not_on_buildpath.title"), message)) { //$NON-NLS-1$
				JUnitGenerator generator;
				IWizard theWizard = getWizard();
				if (theWizard instanceof JUnitTestSuiteNewWizard) {
					generator = ((JUnitTestSuiteNewWizard)theWizard).createGenerator();
				} else {
					// If the current page is used outside of JUnit wizard, use the default
					// generator
					generator = new JUnitGenerator(new AutomaticDependencyUpdater());
				}
				it = missingLibraries.iterator();
				while (it.hasNext()) {
					RequiredLibrary lib = (RequiredLibrary) it.next();
					generator.getProjectDependencyUpdater().addRequiredPlugin(lib.plugin, lib.jarName);
				}
				try {
					updater.adjustProject(jp.getProject(), new NullProgressMonitor());
				} catch (CoreException e) {
					ToolsUiPlugin.logError(e);
				}

		} else {
			return new Status(IStatus.WARNING, ToolsUiPlugin.getID(), 1, ToolsUiPlugin.getString("SourcePage.error.jarsNotOnbuildpath", librariesAsText.toString()), null); //$NON-NLS-1$
		}
				
	}

	protected class RequiredLibrary {
		public String testClass;
		public String plugin;
		public String jarName;
		public RequiredLibrary(String testClass, String plugin, String jarName) {
			this.testClass = testClass;
			this.plugin = plugin;
			this.jarName = jarName;
		}
	}
	
	protected List getRequiredLibraries() {
		List result = new ArrayList(3);
		if (isModelBehavior()) {
			result.add(new RequiredLibrary(Helper.HYADES_TEST_SUITE_CLASS_NAME, CorePlugin.getID(), "common.runner.jar")); //$NON-NLS-1$
			result.add(new RequiredLibrary(Helper.HYADES_JUNIT_RUNNER, CorePlugin.getID(), "java.runner.jar")); //$NON-NLS-1$ //$NON-NLS-2$
		}
		result.add(new RequiredLibrary(Helper.JUNIT_TEST_CLASS_NAME, "org.junit", "junit.jar")); //$NON-NLS-1$ //$NON-NLS-2$
		return result;
	}
	
}




	 */
	public AdjustSourceInfoPage(IImplementor implementor)
	{
		super("AdjustSourceInfoPage"); //$NON-NLS-1$
		setTitle(ToolsUiPlugin.getString("JAVA_GEN_WTITLE")); //$NON-NLS-1$
		setDescription(ToolsUiPlugin.getString("ADJ_PG_DSC")); //$NON-NLS-1$

		this.implementor = implementor;
	}

	{
		if(!JavaConventions.validateIdentifier(sourceInfoViewer.getClassName()).isOK())
		{
			setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_CLS_NAME")); //$NON-NLS-1$
			return false;
		}

		if(!JavaConventions.validatePackageName(sourceInfoViewer.getPackage()).isOK())
		{
			setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_PCK_NAME")); //$NON-NLS-1$
			return false;
		}
		

Lines 16-23 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/wizard/JUnitTestSuiteNewWizard.java (-35 / +24 lines)
16	import org.eclipse.core.runtime.IProgressMonitor;	16	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.IStatus;	17	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.NullProgressMonitor;	18	import org.eclipse.core.runtime.NullProgressMonitor;
		19	import org.eclipse.core.runtime.SubProgressMonitor;
19	import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;	20	import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
20	import org.eclipse.hyades.test.tools.core.CorePlugin;
21	import org.eclipse.hyades.test.tools.core.common.TestCommon;	21	import org.eclipse.hyades.test.tools.core.common.TestCommon;
22	import org.eclipse.hyades.test.tools.core.internal.common.codegen.AutomaticDependencyUpdater;	22	import org.eclipse.hyades.test.tools.core.internal.common.codegen.AutomaticDependencyUpdater;
23	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;	23	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;
Lines 32-37 Link Here
32	import org.eclipse.jdt.core.JavaModelException;	32	import org.eclipse.jdt.core.JavaModelException;
33	import org.eclipse.jface.dialogs.IDialogSettings;	33	import org.eclipse.jface.dialogs.IDialogSettings;
34	import org.eclipse.jface.viewers.IStructuredSelection;	34	import org.eclipse.jface.viewers.IStructuredSelection;
		35	import org.eclipse.ltk.core.refactoring.Change;
		36	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
35		37
36	/**	38	/**
37	* Extends the HyadesNewWizard to create the JUnit Test Suite.	39	* Extends the HyadesNewWizard to create the JUnit Test Suite.
Lines 42-48 Link Here
42	public class JUnitTestSuiteNewWizard extends TestSuiteNewWizard2 {	44	public class JUnitTestSuiteNewWizard extends TestSuiteNewWizard2 {
43		45
44	private SourcePage sourcePage;	46	private SourcePage sourcePage;
45	private ITestSuite generatedTestSuite;
46		47
47	/**	48	/**
48	* Constructor for TestSuiteNewWizard	49	* Constructor for TestSuiteNewWizard
Lines 166-191 Link Here
166	sourcePage_.init(structuredSelection, locationPage);	167	sourcePage_.init(structuredSelection, locationPage);
167	}	168	}
168		169
169	/* (non-Javadoc)
170	* @see org.eclipse.jface.wizard.IWizard#performFinish()
171	*/
172	public boolean performFinish() {
173	// Generate the Test Suite
174	if (super.performFinish()) {
175	if (this.generatedTestSuite != null) {
176	try {
177	// Generate the source code
178	generateCode(this.generatedTestSuite, new NullProgressMonitor());
179	} catch (Exception e) {
180	ToolsUiPlugin.logError(e);
181	return false;
182	}
183	}
184	return true;
185	}
186	return false;
187	}
188
189	protected void adjustTestSuite(ITestSuite testSuite) {	170	protected void adjustTestSuite(ITestSuite testSuite) {
190	// Set the name of the implementor class	171	// Set the name of the implementor class
191	String qualifiedName = this.sourcePage.getQualifiedTypeName();	172	String qualifiedName = this.sourcePage.getQualifiedTypeName();
Lines 204-231 Link Here
204	if (!this.sourcePage.isModelBehavior()) {	185	if (!this.sourcePage.isModelBehavior()) {
205	JUnitModelUpdater.setImplementorBlock(testSuite.getImplementor(), null);	186	JUnitModelUpdater.setImplementorBlock(testSuite.getImplementor(), null);
206	}	187	}
207	this.generatedTestSuite = testSuite;	188	try {
208	// Don't invoke super.registerResource().	189	// Generate the source code
		190	generateCode(testSuite, new NullProgressMonitor());
		191	} catch (Exception e) {
		192	ToolsUiPlugin.logError(e);
		193	}
		194	// Don't invoke super.adjustTestSuite().
209	}	195	}
210		196
211	protected SourcePage getSourcePage() {	197	protected SourcePage getSourcePage() {
212	return this.sourcePage;	198	return this.sourcePage;
213	}	199	}
214		200
215	protected ITestSuite getGeneratedTestSuite() {	201	protected JUnitGenerator createGenerator(ITestSuite testSuite) {
216	return this.generatedTestSuite;	202	return new JUnitGenerator(testSuite, new AutomaticDependencyUpdater(), getSourcePage().getSuperClass());
217	}
218
219	protected JUnitGenerator createGenerator() {
220	return new JUnitGenerator(new AutomaticDependencyUpdater(), getSourcePage().getSuperClass());
221	}	203	}
222		204
223	private void generateCode(ITestSuite testSuite, IProgressMonitor monitor) throws Exception {	205	private void generateCode(ITestSuite testSuite, IProgressMonitor monitor) throws Exception {
224	JUnitGenerator generator = createGenerator();	206	monitor.beginTask("", 4); //$NON-NLS-1$
225	generator.getProjectDependencyUpdater().addRequiredPlugin("org.junit", null); //$NON-NLS-1$	207	try {
226	generator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$	208	JUnitGenerator generator = createGenerator(testSuite);
227	generator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "java.runner.jar"); //$NON-NLS-1$	209	RefactoringStatus status = generator.checkAllConditions(new SubProgressMonitor(monitor, 1));
228	generator.generate(getGeneratedTestSuite(), monitor);	210	if (status.hasFatalError()) {
		211	throw new IllegalStateException("Refactor conditions not met"); // TODO Treat this appropriately //$NON-NLS-1$
		212	}
		213	Change change = generator.createChange(new SubProgressMonitor(monitor, 1));
		214	change.perform(new SubProgressMonitor(monitor, 2));
		215	} finally {
		216	monitor.done();
		217	}
229	}	218	}
230		219
231	protected void setSourcePage(SourcePage page) {	220	protected void setSourcePage(SourcePage page) {




public class ProjectAndSourcePage 
extends WizardPage implements ModifyListener, SelectionListener
{
	protected static final String SET_PROJECT = "PROJECT_NAME"; //$NON-NLS-1$
	protected static final String SET_SOURCE = "SOURCE_FOLDER_NAME"; //$NON-NLS-1$

	private IImplementor implementor;
	private IJavaProject[] javaProjects;

	 */
	public ProjectAndSourcePage(IImplementor implementor, IJavaProject[] javaProjects)
	{
		super("ProjectAndSourcePage"); //$NON-NLS-1$
		setTitle(ToolsUiPlugin.getString("JAVA_GEN_WTITLE")); //$NON-NLS-1$
		setDescription(ToolsUiPlugin.getString("JAVA_GEN_LDESC")); //$NON-NLS-1$
		
		this.implementor = implementor;
		this.javaProjects = javaProjects;

		composite.setLayoutData(GridDataUtil.createFill());
		
		Label label = new Label(composite, SWT.NONE);
		label.setText(ToolsUiPlugin.getString("STR_WB_PROJECT")); //$NON-NLS-1$
		
		javaProjectText = new Text(composite, SWT.BORDER | SWT.SINGLE);
		javaProjectText.setLayoutData(GridDataUtil.createHorizontalFill());

		GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
		gridData.horizontalSpan = 2;
		selectJavaProjectButton.setLayoutData(gridData);
		selectJavaProjectButton.setText(ToolsUiPlugin.getString("STR_WB_BROWSE_BTN")); //$NON-NLS-1$
		selectJavaProjectButton.addSelectionListener(this);
		selectJavaProjectButton.setEnabled(javaProjects.length > 0);
		
		label = new Label(composite, SWT.NONE);
		label.setText(ToolsUiPlugin.getString("STR_WB_SRC_FOLDER")); //$NON-NLS-1$

		sourceFolderText = new Text(composite, SWT.BORDER | SWT.SINGLE);
		sourceFolderText.setLayoutData(GridDataUtil.createHorizontalFill());

		gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
		gridData.horizontalSpan = 2;
		selectSourceFolderButton.setLayoutData(gridData);
		selectSourceFolderButton.setText(ToolsUiPlugin.getString("STR_WB_SOURCE_BTN")); //$NON-NLS-1$
		selectSourceFolderButton.addSelectionListener(this);
		
		

			setPageComplete(false);
			selectSourceFolderButton.setEnabled(false); 
			javaProjectText.setEditable(false);
			setErrorMessage(ToolsUiPlugin.getString("NO_JAVA_PRJ")); //$NON-NLS-1$
			composite.setFocus();
		}
			

		String value = javaProjectText.getText();
		if(value.trim().length() == 0)
		{
			setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_EMPTY_PROJECT")); //$NON-NLS-1$
			return false;
		}
		
		IJavaProject javaProject = getJavaProject(value);
		if(javaProject == null)
		{
			setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_NOT_EXIST_PROJECT")); //$NON-NLS-1$
			return false;
		}
		

			value = sourceFolderText.getText();
			if(value.trim().length() == 0)
			{
				setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_EMPTY_FOLDER")); //$NON-NLS-1$
				return false;
			}
			
			if(!isValidFolderName())
			{
				setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_FLD_NME")); //$NON-NLS-1$
				return false;
			}
		}

	protected boolean isValidFolderName()
	{
		String folder = getSourceFolder();
		if(folder.startsWith("/")) //$NON-NLS-1$
			return false;

		if(folder.endsWith("/")) //$NON-NLS-1$
			return false;
			
		return true;

		if(sourceFolderText.getEditable())
			return sourceFolderText.getText().trim().replace('\\', '/');
			
		return ""; //$NON-NLS-1$
	}

	protected IJavaProject getJavaProject()

	{
		ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
		ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), labelProvider);
		dialog.setTitle(ToolsUiPlugin.getString("TITLE_PROJECT_SELECT")); //$NON-NLS-1$
		dialog.setMessage(ToolsUiPlugin.getString("STR_PROJECT_SELECT")); //$NON-NLS-1$
		dialog.setElements(javaProjects);

		IJavaProject javaProject = getJavaProject(javaProjectText.getText());

	protected Object chooseSourceFolder()
	{
		ElementTreeSelectionDialog dialog = TestJavaUtil.createSourceFolderDialog(getShell(), null);
		dialog.setTitle(ToolsUiPlugin.getString("TITLE_SRC_SELECT")); //$NON-NLS-1$
		dialog.setMessage(ToolsUiPlugin.getString("STR_SRC_SELECT")); //$NON-NLS-1$

		IJavaProject javaProject = getJavaProject(javaProjectText.getText());
		if (javaProject != null)

Lines 15-22 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/wizard/GenerateWizard.java (-12 / +15 lines)
15	import java.lang.reflect.InvocationTargetException;	15	import java.lang.reflect.InvocationTargetException;
16		16
17	import org.eclipse.core.resources.IContainer;	17	import org.eclipse.core.resources.IContainer;
		18	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.core.runtime.IProgressMonitor;	19	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.IStatus;	20	import org.eclipse.core.runtime.NullProgressMonitor;
20	import org.eclipse.core.runtime.Path;	21	import org.eclipse.core.runtime.Path;
21	import org.eclipse.emf.ecore.EObject;	22	import org.eclipse.emf.ecore.EObject;
22	import org.eclipse.emf.ecore.resource.Resource;	23	import org.eclipse.emf.ecore.resource.Resource;
Lines 39-44 Link Here
39	import org.eclipse.jface.operation.IRunnableWithProgress;	40	import org.eclipse.jface.operation.IRunnableWithProgress;
40	import org.eclipse.jface.viewers.IStructuredSelection;	41	import org.eclipse.jface.viewers.IStructuredSelection;
41	import org.eclipse.jface.wizard.Wizard;	42	import org.eclipse.jface.wizard.Wizard;
		43	import org.eclipse.ltk.core.refactoring.Change;
		44	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
42	import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;	45	import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
43		46
44	/**	47	/**
Lines 100-106 Link Here
100	IImplementor implementor = getTestSuite().getImplementor();	103	IImplementor implementor = getTestSuite().getImplementor();
101	this.generator = createGenerator();	104	this.generator = createGenerator();
102		105
103	if (generator.validate(testSuite).getSeverity() == IStatus.OK) {	106	boolean isOk = false;
		107	try {
		108	RefactoringStatus status = generator.checkAllConditions(new NullProgressMonitor());
		109	isOk = status.isOK();
		110	} catch (CoreException e) {
		111	ToolsUiPlugin.logError(e);
		112	}
		113	if (isOk) {
104	// Show only the project and source page	114	// Show only the project and source page
105	IJavaProject[] javaProjects = TestJavaUtil.getJavaProjects();	115	IJavaProject[] javaProjects = TestJavaUtil.getJavaProjects();
106	projectAndSourcePage = new ProjectAndSourcePage(implementor, javaProjects);	116	projectAndSourcePage = new ProjectAndSourcePage(implementor, javaProjects);
Lines 162-171 Link Here
162	}	172	}
163	}	173	}
164		174
165	addRequiredLibraries(generator);
166	try	175	try
167	{	176	{
168	generator.generate(getTestSuite(), mon);	177	Change change = generator.createChange(new NullProgressMonitor());
		178	change.perform(new NullProgressMonitor());
169	}	179	}
170	catch(Exception e)	180	catch(Exception e)
171	{	181	{
Lines 226-239 Link Here
226		236
227	protected Generator createGenerator()	237	protected Generator createGenerator()
228	{	238	{
229	return new JUnitGenerator(new AutomaticDependencyUpdater());	239	return new JUnitGenerator(getTestSuite(), new AutomaticDependencyUpdater());
230	}	240	}
231		241
232	protected void addRequiredLibraries(Generator generator)
233	{
234	JUnitGenerator junitGenerator = (JUnitGenerator)generator;
235	junitGenerator.getProjectDependencyUpdater().addRequiredPlugin(PLUGIN_ID_JUNIT, null);
236	junitGenerator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$
237	junitGenerator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "java.runner.jar"); //$NON-NLS-1$
238	}
239	}	242	}





package org.eclipse.hyades.test.tools.ui.http.internal.junit.wizard;

import org.eclipse.hyades.test.tools.core.internal.common.codegen.AutomaticDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.Generator;
import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.hyades.test.tools.ui.http.internal.codegen.HttpGenerator;
import org.eclipse.hyades.test.tools.ui.java.internal.junit.wizard.GenerateWizard;

public class HttpGenerateWizard extends GenerateWizard {
	
{
    public HttpGenerateWizard() {
        super();
        setWindowTitle(ToolsUiPlugin.getString("GEN_WTITLE")); //$NON-NLS-1$

	 */
	protected Generator createGenerator()
	{
		return new HttpGenerator(getTestSuite(), new AutomaticDependencyUpdater());
	}
	
	/**
	 * @see org.eclipse.hyades.test.java.internal.junit.wizard.GenerateWizard#addRequiredLibraries(org.eclipse.hyades.test.common.internal.codegen.Generator)
	 */
	protected void addRequiredLibraries(Generator generator)
	{
		HttpGenerator httpGenerator = (HttpGenerator)generator;
		httpGenerator.getProjectDependencyUpdater().addRequiredPlugin(PLUGIN_ID_JUNIT, null);
		httpGenerator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$
		httpGenerator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "http.runner.jar"); //$NON-NLS-1$

		//add additional libraries in order to run as a JUnit - bugzilla_98741  jn
		httpGenerator.getProjectDependencyUpdater().addRequiredPlugin("org.eclipse.hyades.logging.core", null); //$NON-NLS-1$
		httpGenerator.getProjectDependencyUpdater().addRequiredPlugin("org.eclipse.emf.ecore", null); //$NON-NLS-1$
		httpGenerator.getProjectDependencyUpdater().addRequiredPlugin("org.eclipse.emf.common", null); //$NON-NLS-1$
	}
}

Lines 441-446 Link Here

(-)plugin.xml (+26 lines)
441	id="org.eclipse.hyades.test.tools.ui.JUnitTestSuiteOpenCode"/>	441	id="org.eclipse.hyades.test.tools.ui.JUnitTestSuiteOpenCode"/>
442	</objectContribution>	442	</objectContribution>
443	</extension>	443	</extension>
		444	<extension
		445	point="org.eclipse.ui.popupMenus">
		446	<objectContribution
		447	adaptable="false"
		448	objectClass="org.eclipse.hyades.test.ui.internal.navigator.proxy.DefaultTestCaseProxyNode"
		449	id="org.eclipse.hyades.test.tools.ui.JUnitTestCaseContribution">
		450	<action
		451	enablesFor="1"
		452	label="%OPEN_JUNIT_TEST_SUITE_CODE"
		453	class="org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator.actions.OpenJUnitTestSuiteCodeAction"
		454	menubarPath="org.eclipse.ui.OpenWithSubMenu"
		455	id="org.eclipse.hyades.test.tools.ui.JUnitTestCaseOpenCode"/>
		456	</objectContribution>
		457	</extension>
444		458
445	<!-- ####################################################################### -->	459	<!-- ####################################################################### -->
446	<!-- Plugin JUnit extensions -->	460	<!-- Plugin JUnit extensions -->
Lines 566-570 Link Here
566	recorderMessageHandlers="org.eclipse.hyades.execution.recorder.http.local.HttpRecorderDataProcessor"	580	recorderMessageHandlers="org.eclipse.hyades.execution.recorder.http.local.HttpRecorderDataProcessor"
567	wizardPageProvider="org.eclipse.tptp.test.tools.internal.recorder.http.providers.HttpRecorderWizardProvider"/>	581	wizardPageProvider="org.eclipse.tptp.test.tools.internal.recorder.http.providers.HttpRecorderWizardProvider"/>
568	</extension>	582	</extension>
		583	<extension
		584	point="org.eclipse.ui.preferencePages">
		585	<page
		586	category="org.eclipse.hyades.test.ui.internal.preference.TestPreferencePage"
		587	class="org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences.JUnitPreferencesPage"
		588	id="junit"
		589	name="%JUNIT_PREFS_PAGE_TITLE"/>
		590	</extension>
		591	<extension
		592	point="org.eclipse.core.runtime.preferences">
		593	<initializer class="org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences.JUnitPreferences"/>
		594	</extension>
569		595
570	</plugin>	596	</plugin>

Lines 110-115 Link Here

(-)plugin.properties (-1 / +15 lines)
110	STR_WB_PROJECT = &Java Project:	110	STR_WB_PROJECT = &Java Project:
111	STR_WB_SRC_FOLDER = Source &Folder:	111	STR_WB_SRC_FOLDER = Source &Folder:
112	STR_WB_SOURCE_BTN = B&rowse...	112	STR_WB_SOURCE_BTN = B&rowse...
		113	SOURCE_INFO_VIEWER_OPEN_CLASS = Open
113	_ERROR_WIZ_EMPTY_PROJECT = Java project name cannot be empty.	114	_ERROR_WIZ_EMPTY_PROJECT = Java project name cannot be empty.
114	_ERROR_WIZ_EMPTY_FOLDER = Source folder name cannot be empty.	115	_ERROR_WIZ_EMPTY_FOLDER = Source folder name cannot be empty.
115	_ERROR_WIZ_NOT_EXIST_PROJECT = Java project does not exist.	116	_ERROR_WIZ_NOT_EXIST_PROJECT = Java project does not exist.
Lines 130-135 Link Here
130	NO_PACK = There is no packages in the workspace.	131	NO_PACK = There is no packages in the workspace.
131	NO_SRC = There are no source folders in the workspace.	132	NO_SRC = There are no source folders in the workspace.
132	STR_BTN_CREATE = &Create...	133	STR_BTN_CREATE = &Create...
		134	CODE_UPDATE = Code Update
		135	CODE_UPDATE_PREVIEW = Code Update Preview
133		136
134	WIZ_ERR_NOT_EXIST_FOLDER = Selected location is not a source folder.	137	WIZ_ERR_NOT_EXIST_FOLDER = Selected location is not a source folder.
135		138
Lines 153-159 Link Here
153	W_LWR_INV = invocation	156	W_LWR_INV = invocation
154	Q_OVR_FILE = This test has been previously generated.\nIf you have made manual changes to the existing files they will be lost.\n\nWould you like to continue?	157	Q_OVR_FILE = This test has been previously generated.\nIf you have made manual changes to the existing files they will be lost.\n\nWould you like to continue?
155		158
156		159	#Code Update wizard
		160	CODE_UPDATE_OPTIONS=JUnit Code Update Preview Options
		161	UPDATE_CODE_PAGE_DESCR=Define the options related to code update preview.
		162	ALWAYS_SKIP_TO_PREVIEW=Always skip to the preview page
		163	SHOW_PREVIEW=Show the preview page
		164	ALWAYS=Always
		165	ONLY_IF_DESTRUCTIVE=Only when there are destructive changes
		166	NEVER=Never
		167
		168	#JUnit preferences
		169	CODE_UPDATE_GROUP=Code update
		170	JUNIT_PREFS_PAGE_TITLE=TPTP JUnit
157		171
158	###############################################################################	172	###############################################################################
159	# HTTP properties	173	# HTTP properties

Lines 12-17 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/plugin/internal/junit/wizard/PluginJUnitTestSuiteNewWizard.java (-2 / +3 lines)
12		12
13	package org.eclipse.hyades.test.tools.ui.plugin.internal.junit.wizard;	13	package org.eclipse.hyades.test.tools.ui.plugin.internal.junit.wizard;
14		14
		15	import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
15	import org.eclipse.hyades.test.tools.core.common.TestCommon;	16	import org.eclipse.hyades.test.tools.core.common.TestCommon;
16	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;	17	import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator;
17	import org.eclipse.hyades.test.tools.core.internal.plugin.codegen.PluginProjectDependencyUpdater;	18	import org.eclipse.hyades.test.tools.core.internal.plugin.codegen.PluginProjectDependencyUpdater;
Lines 53-60 Link Here
53	return TestCommon.PLUGIN_JUNIT_TEST_SUITE_TYPE;	54	return TestCommon.PLUGIN_JUNIT_TEST_SUITE_TYPE;
54	}	55	}
55		56
56	protected JUnitGenerator createGenerator() {	57	protected JUnitGenerator createGenerator(ITestSuite testSuite) {
57	return new JUnitGenerator(new PluginProjectDependencyUpdater(), getSourcePage().getSuperClass());	58	return new JUnitGenerator(testSuite, new PluginProjectDependencyUpdater(), getSourcePage().getSuperClass());
58	}	59	}
59		60
60	protected void initSourcePage(IStructuredSelection structuredSelection, LocationPage locationPage) {	61	protected void initSourcePage(IStructuredSelection structuredSelection, LocationPage locationPage) {




 **********************************************************************/
package org.eclipse.hyades.test.tools.ui.http.internal.codegen;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.test.tools.core.CorePlugin;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.DelegateProjectDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.IProjectDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.JavaGenerator;
import org.eclipse.hyades.test.tools.core.internal.java.codegen.JUnitGenerator.JUnitProjectDependencyUpdater;

/**
 * @author marcelop
 * @since 1.0.2
 */
public class HttpGenerator extends JavaGenerator {
{
	
	public final static String PLUGIN_ID_JUNIT = "org.junit"; //$NON-NLS-1$
	public final static String PLUGIN_ID_EXECUTION_CORE = "org.eclipse.hyades.execution.core"; //$NON-NLS-1$
	public final static String PLUGIN_ID_EXECUTION_REMOTE = "org.eclipse.hyades.execution.remote"; //$NON-NLS-1$

	public HttpGenerator(ITestSuite testSuite, IProjectDependencyUpdater updater) {
		super(testSuite, new HttpProjectDependencyUpdater(updater));
	}
	
	/**
	 * @see org.eclipse.hyades.test.common.internal.codegen.Generator#generateFile(org.eclipse.hyades.models.common.facades.behavioral.ITestSuite, org.eclipse.core.resources.IFile, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected String generateCode(IProgressMonitor monitor) throws CoreException
	throws Exception
	{
		GenTestSuite genTestSuite = new GenTestSuite();
		Helper helper = new Helper();
		computeTestMethodNames(getTestSuite(), false, helper);
		String content = Helper.formatContent(genTestSuite.generate(getTestSuite(), helper));
		helper.dispose();
		return content;
	}

	static class HttpProjectDependencyUpdater extends DelegateProjectDependencyUpdater {

		public HttpProjectDependencyUpdater(IProjectDependencyUpdater delegate) {
			super(delegate);
			addRequiredPlugin(PLUGIN_ID_JUNIT, null);
			addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$
			addRequiredPlugin(CorePlugin.getID(), "http.runner.jar"); //$NON-NLS-1$
			//add additional libraries in order to run as a JUnit - bugzilla_98741  jn
			addRequiredPlugin("org.eclipse.hyades.logging.core", null); //$NON-NLS-1$
			addRequiredPlugin("org.eclipse.emf.ecore", null); //$NON-NLS-1$
			addRequiredPlugin("org.eclipse.emf.common", null); //$NON-NLS-1$
		}
		
	}

}

Lines 12-25 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/navigator/actions/OpenJUnitTestSuiteCodeAction.java (-8 / +61 lines)
12	package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator.actions;	12	package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator.actions;
13		13
14	import org.eclipse.core.resources.IFile;	14	import org.eclipse.core.resources.IFile;
		15	import org.eclipse.hyades.models.common.testprofile.TPFTestCase;
15	import org.eclipse.hyades.models.common.testprofile.TPFTestSuite;	16	import org.eclipse.hyades.models.common.testprofile.TPFTestSuite;
		17	import org.eclipse.hyades.test.tools.core.internal.common.codegen.Helper;
16	import org.eclipse.hyades.test.tools.core.java.JUnitTestSuiteFacade;	18	import org.eclipse.hyades.test.tools.core.java.JUnitTestSuiteFacade;
		19	import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
17	import org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator.JUnitTestSuiteProxyNode;	20	import org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator.JUnitTestSuiteProxyNode;
		21	import org.eclipse.hyades.test.ui.internal.navigator.proxy.DefaultTestCaseProxyNode;
		22	import org.eclipse.hyades.test.ui.navigator.IProxyNode;
18	import org.eclipse.hyades.ui.internal.util.UIUtil;	23	import org.eclipse.hyades.ui.internal.util.UIUtil;
		24	import org.eclipse.jdt.core.ICompilationUnit;
		25	import org.eclipse.jdt.core.IJavaElement;
		26	import org.eclipse.jdt.core.IMethod;
		27	import org.eclipse.jdt.core.IType;
		28	import org.eclipse.jdt.core.JavaCore;
		29	import org.eclipse.jdt.core.JavaModelException;
		30	import org.eclipse.jdt.ui.JavaUI;
19	import org.eclipse.jface.action.IAction;	31	import org.eclipse.jface.action.IAction;
20	import org.eclipse.jface.viewers.ISelection;	32	import org.eclipse.jface.viewers.ISelection;
21	import org.eclipse.jface.viewers.IStructuredSelection;	33	import org.eclipse.jface.viewers.IStructuredSelection;
22	import org.eclipse.ui.IActionDelegate;	34	import org.eclipse.ui.IActionDelegate;
		35	import org.eclipse.ui.IEditorPart;
		36	import org.eclipse.ui.PartInitException;
23		37
24	/**	38	/**
25	* Action to open the source code of a JUnit test suite.	39	* Action to open the source code of a JUnit test suite.
Lines 34-47 Link Here
34	* @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)	48	* @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
35	*/	49	*/
36	public void run(IAction action) {	50	public void run(IAction action) {
37	TPFTestSuite ts = ((JUnitTestSuiteProxyNode)selection.getFirstElement()).getTestSuite();	51	IProxyNode proxy = (IProxyNode) selection.getFirstElement();
38	IFile javaFile = JUnitTestSuiteFacade.getJUnitSourceFile(ts);	52	if (proxy instanceof JUnitTestSuiteProxyNode) {
39	if(javaFile != null) {	53	TPFTestSuite ts = ((JUnitTestSuiteProxyNode)proxy).getTestSuite();
40	UIUtil.openEditor(javaFile, null, false);	54	IFile javaFile = JUnitTestSuiteFacade.getJUnitSourceFile(ts);
41	}	55	if(javaFile != null) {
42	if(ts.eResource() != null) {	56	UIUtil.openEditor(javaFile, null, false);
43	ts.eResource().unload();	57	}
44	}	58	if(ts.eResource() != null) {
		59	ts.eResource().unload();
		60	}
		61	} else if (proxy instanceof DefaultTestCaseProxyNode) {
		62	DefaultTestCaseProxyNode tcpn = (DefaultTestCaseProxyNode)proxy;
		63	if (tcpn.getParent() instanceof JUnitTestSuiteProxyNode) {
		64	TPFTestCase tc = tcpn.getTestCase();
		65	IFile javaFile = JUnitTestSuiteFacade.getJUnitSourceFile(tc.getTestSuite());
		66	ICompilationUnit cu = JavaCore.createCompilationUnitFrom(javaFile);
		67	try {
		68	if (cu.exists() && cu.isStructureKnown()) {
		69	String methodName = Helper.getTestMethodName(tc);
		70	IType primaryType = cu.findPrimaryType();
		71	if (primaryType != null && tc != null) {
		72	IMethod m = findMethodWithNoParameter(primaryType, methodName);
		73	if (m != null) {
		74	IEditorPart part = JavaUI.openInEditor(m);
		75	JavaUI.revealInEditor(part, (IJavaElement)m);
		76	}
		77	}
		78	}
		79	} catch (JavaModelException e) {
		80	ToolsUiPlugin.logError(e);
		81	} catch (PartInitException e) {
		82	ToolsUiPlugin.logError(e);
		83	}
		84	}
		85	}
		86	}
		87
		88	private IMethod findMethodWithNoParameter(IType type, String name) throws JavaModelException {
		89	IMethod[] methods = type.getMethods();
		90	for (int i = 0; i < methods.length; i++) {
		91	if (name.equals(methods[i].getElementName())) {
		92	if (methods[i].getParameterTypes().length == 0) {
		93	return methods[i];
		94	}
		95	}
		96	}
		97	return null;
45	}	98	}
46		99
47	/* (non-Javadoc)	100	/* (non-Javadoc)

Lines 69-73 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
69	org.eclipse.tptp.platform.report.core;bundle-version="[4.1.100,5.0.0)",	69	org.eclipse.tptp.platform.report.core;bundle-version="[4.1.100,5.0.0)",
70	org.eclipse.ui.forms;bundle-version="[3.2.0,4.0.0)",	70	org.eclipse.ui.forms;bundle-version="[3.2.0,4.0.0)",
71	org.eclipse.pde.core;bundle-version="[3.2.0,4.0.0)",	71	org.eclipse.pde.core;bundle-version="[3.2.0,4.0.0)",
72	org.eclipse.pde.ui;bundle-version="[3.2.0,4.0.0)"	72	org.eclipse.pde.ui;bundle-version="[3.2.0,4.0.0)",
		73	org.eclipse.ltk.ui.refactoring;bundle-version="[3.2.0,4.0.0)"
73	Eclipse-LazyStart: true	74	Eclipse-LazyStart: true




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences;

import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;

public class JUnitCodeUpdatePreviewOptionsControl extends Composite {

	private Button skipPage;
	private Button alwaysPreview;
	private Button onlyDestructive;
	private Button neverPreview;
	
	public JUnitCodeUpdatePreviewOptionsControl(Composite parent, int style) {
		super(parent, style);
		GridLayout layout = new GridLayout(1, false);
		layout.verticalSpacing = 15;
		setLayout(layout);
		
		Control group = createPreviewGroup();
		group.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
		
		skipPage = new Button(this, SWT.CHECK);
		skipPage.setText(ToolsUiPlugin.getString("ALWAYS_SKIP_TO_PREVIEW")); //$NON-NLS-1$
	}

	/**
	 * @param parent
	 */
	private Control createPreviewGroup() {
		Group composite = new Group(this, SWT.NONE);
		composite.setText(ToolsUiPlugin.getString("SHOW_PREVIEW")); //$NON-NLS-1$
		RowLayout layout = new RowLayout(SWT.VERTICAL);
		layout.spacing = 6;
		layout.marginWidth = 5;
		layout.marginHeight = 6;
		composite.setLayout(layout);
		
		alwaysPreview = new Button(composite, SWT.RADIO);
		alwaysPreview.setText(ToolsUiPlugin.getString("ALWAYS")); //$NON-NLS-1$
		
		onlyDestructive = new Button(composite, SWT.RADIO);
		onlyDestructive.setText(ToolsUiPlugin.getString("ONLY_IF_DESTRUCTIVE")); //$NON-NLS-1$
		
		neverPreview = new Button(composite, SWT.RADIO);
		neverPreview.setText(ToolsUiPlugin.getString("NEVER")); //$NON-NLS-1$
		return composite;
	}
	
	private void resetPreview() {
		alwaysPreview.setSelection(false);
		onlyDestructive.setSelection(false);
		neverPreview.setSelection(false);
	}
	
	public void initialize(IPreferenceStore prefs) {
		resetPreview();
		switch (prefs.getInt(JUnitPreferences.UPDATE_PREVIEW_MODE)) {
		case JUnitPreferences.PREVIEW_ALWAYS:
			alwaysPreview.setSelection(true);
			break;
		case JUnitPreferences.PREVIEW_IF_DESTRUCTIVE:
			onlyDestructive.setSelection(true);
			break;
		case JUnitPreferences.PREVIEW_NEVER:
			neverPreview.setSelection(true);
			break;
		}
		skipPage.setSelection(prefs.getBoolean(JUnitPreferences.SKIP_TO_PREVIEW_PAGE));
	}
	
	public void save(IPreferenceStore prefs) {
		int value;
		if (alwaysPreview.getSelection()) {
			value = JUnitPreferences.PREVIEW_ALWAYS;
		} else if (onlyDestructive.getSelection()) {
			value = JUnitPreferences.PREVIEW_IF_DESTRUCTIVE;
		} else {
			value = JUnitPreferences.PREVIEW_NEVER;
		}
		prefs.setValue(JUnitPreferences.UPDATE_PREVIEW_MODE, value);
		prefs.setValue(JUnitPreferences.SKIP_TO_PREVIEW_PAGE, skipPage.getSelection());
	}

	public void resetToDefaults(IPreferenceStore prefs) {
		resetPreview();
		switch (prefs.getDefaultInt(JUnitPreferences.UPDATE_PREVIEW_MODE)) {
		case JUnitPreferences.PREVIEW_ALWAYS:
			alwaysPreview.setSelection(true);
			break;
		case JUnitPreferences.PREVIEW_IF_DESTRUCTIVE:
			onlyDestructive.setSelection(true);
			break;
		case JUnitPreferences.PREVIEW_NEVER:
			neverPreview.setSelection(true);
			break;
		}
		skipPage.setSelection(prefs.getDefaultBoolean(JUnitPreferences.SKIP_TO_PREVIEW_PAGE));
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences;

import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;

public class JUnitPreferencesPage extends PreferencePage implements IWorkbenchPreferencePage {

	private JUnitCodeUpdatePreviewOptionsControl previewOptions;
	
	public JUnitPreferencesPage() {
		setPreferenceStore(ToolsUiPlugin.getDefault().getPreferenceStore());
	}
	
	protected Control createContents(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(1, true);
		composite.setLayout(layout);
		Control codeupdate = createCodeUpdateGroup(composite);
		codeupdate.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
		return composite;
	}
	
	private Control createCodeUpdateGroup(Composite parent) {
		Group previewGroup = new Group(parent, SWT.None);
		previewGroup.setText(ToolsUiPlugin.getString("CODE_UPDATE_GROUP")); //$NON-NLS-1$
		previewGroup.setLayout(new RowLayout(SWT.VERTICAL));
		
		previewOptions = new JUnitCodeUpdatePreviewOptionsControl(previewGroup, SWT.NONE);
		previewOptions.initialize(getPreferenceStore());
		
		return previewGroup;
	}

	public boolean performOk() {
		previewOptions.save(getPreferenceStore());
		return true;
	}
	
	protected void performDefaults() {
		previewOptions.resetToDefaults(getPreferenceStore());
		super.performDefaults();
	}

	public void init(IWorkbench workbench) {
		// NOP
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;


/**
 * Preferences constants for JUnit preferences.
 * @author jcanches
 * @since 4.3
 */
public class JUnitPreferences extends AbstractPreferenceInitializer {

	public final static String UPDATE_PREVIEW_MODE = "junit.previewMode"; //$NON-NLS-1$
	public final static int PREVIEW_ALWAYS = 0;
	public final static int PREVIEW_IF_DESTRUCTIVE = 1;
	public final static int PREVIEW_NEVER = 2;
	public final static int DEFAULT_UPDATE_PREVIEW_MODE = PREVIEW_ALWAYS;
	
	public final static String SKIP_TO_PREVIEW_PAGE = "junit.skipToPreviewPage"; //$NON-NLS-1$
	public final static boolean DEFAULT_SKIP_TO_PREVIEW_PAGE = false;
	
	public void initializeDefaultPreferences() {
		Preferences prefs = ToolsUiPlugin.getDefault().getPluginPreferences();
		prefs.setDefault(UPDATE_PREVIEW_MODE, DEFAULT_UPDATE_PREVIEW_MODE);
		prefs.setDefault(SKIP_TO_PREVIEW_PAGE, DEFAULT_SKIP_TO_PREVIEW_PAGE);
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.ui.java.internal.junit.wizard;

import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences.JUnitCodeUpdatePreviewOptionsControl;
import org.eclipse.ltk.ui.refactoring.UserInputWizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;

public class UpdateCodeWizardPage extends UserInputWizardPage {

	private JUnitCodeUpdatePreviewOptionsControl control;
	
	protected UpdateCodeWizardPage() {
		super("UpdateCodeWizardPage"); //$NON-NLS-1$
		setTitle(ToolsUiPlugin.getString("CODE_UPDATE_OPTIONS")); //$NON-NLS-1$
		setDescription(ToolsUiPlugin.getString("UPDATE_CODE_PAGE_DESCR")); //$NON-NLS-1$
	}

	public void createControl(Composite parent) {
		initializeDialogUnits(parent);
		control = new JUnitCodeUpdatePreviewOptionsControl(parent, SWT.NONE);
		control.initialize(ToolsUiPlugin.getDefault().getPreferenceStore());
		setControl(control);
	}
	
	/* package */ void saveContent() {
		control.save(ToolsUiPlugin.getDefault().getPreferenceStore());
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.tools.ui.java.internal.junit.wizard;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.hyades.test.tools.ui.java.internal.junit.preferences.JUnitPreferences;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.ui.refactoring.RefactoringWizard;

public class UpdateCodeWizard extends RefactoringWizard {

	UpdateCodeWizardPage previewOptionsPage;
	
	public UpdateCodeWizard(Refactoring refactoring, boolean showPreview) {
		super(refactoring, computeFlags(showPreview));
	}
	
	private static int computeFlags(boolean showPreview) {
		int flags = RefactoringWizard.WIZARD_BASED_USER_INTERFACE;
		if (!showPreview) flags |= RefactoringWizard.NO_PREVIEW_PAGE;
		return flags;
	}
	
	protected void addUserInputPages() {
		previewOptionsPage = new UpdateCodeWizardPage();
		addPage(previewOptionsPage);
	}

	public IWizardPage getStartingPage() {
		Preferences prefs = ToolsUiPlugin.getDefault().getPluginPreferences();
		boolean skipFirstPage = prefs.getBoolean(JUnitPreferences.SKIP_TO_PREVIEW_PAGE);
		if (skipFirstPage) {
			return super.getStartingPage().getNextPage();
		} else {
			return super.getStartingPage();
		}
	}

	public boolean performFinish() {
		previewOptionsPage.saveContent();
		return super.performFinish();
	}
	
}

Return to bug 134254

Lines 23-37 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/CommonPluginMessages.java (-1 / +29 lines)
23	NLS.initializeMessages(BUNDLE_NAME, CommonPluginMessages.class);	23	NLS.initializeMessages(BUNDLE_NAME, CommonPluginMessages.class);
24	}	24	}
25		25
26	public static String E_CODEGEN_PACK_DIAG;	26	public static String ADJUST_CLASSPATH;
		27	public static String ASSOCIATE_TEST_TO_SOURCE;
		28	public static String CREATE_CONTAINER;
		29	public static String CREATE_PACKAGE;
		30	public static String DEFAULT_PACKAGE;
		31	public static String DEFINE_SOURCE_FOLDER;
		32	public static String DELETE_FILE;
		33	public static String DELETING_FILE;
		34	public static String E_CODEGEN_PACK_DIAG;
27	public static String E_CODEGEN_CLASS_DIAG;	35	public static String E_CODEGEN_CLASS_DIAG;
28	public static String E_CODEGEN_CLOSED_PROJECT;	36	public static String E_CODEGEN_CLOSED_PROJECT;
29	public static String E_CODEGEN_NO_SRCFOLDER;	37	public static String E_CODEGEN_NO_SRCFOLDER;
30		38
31	public static String _ERROR_LAUNCH_VALIDATOR;	39	public static String _ERROR_LAUNCH_VALIDATOR;
32	public static String _WARNING_LAUNCH_VALIDATOR;	40	public static String _WARNING_LAUNCH_VALIDATOR;
		41	public static String E_COMP_UNIT_READ_ONLY;
		42	public static String GENERATE_CODE;
		43	public static String GENERATE_FILE;
		44	public static String GENERATING_FILE;
		45	public static String GENERIC_GENERATOR;
		46	public static String JavaGenerator_W_COMP_UNIT_UNSAVED_CHANGES;
		47	public static String MOVE_COMPILATION_UNIT;
		48	public static String MOVE_RENAME_COMPILATION_UNIT;
		49	public static String NO_FILE;
		50	public static String NO_SOURCE_FOLDER;
		51	public static String NOT_A_SOURCE_FOLDER;
		52	public static String NOT_IN_JAVA_PROJECT;
		53	public static String PROJECT_NOT_ACCESSIBLE;
		54	public static String READ_ONLY_FILE;
		55	public static String RENAME_COMPILATION_UNIT;
		56	public static String RESOURCE_NOT_ACCESSIBLE;
		57	public static String SETUP_CONTEXT;
		58	public static String UNKNOWN_LOCATION;
		59	public static String UPDATE_CODE;
33	public static String VALIDATION_NO_HOST_NAME_ERROR;	60	public static String VALIDATION_NO_HOST_NAME_ERROR;
34	public static String VALIDATION_BAD_ROOTDIR_ERROR_;	61	public static String VALIDATION_BAD_ROOTDIR_ERROR_;
35	public static String _WARNING_BUILD_PATH_PROBLEM;	62	public static String _WARNING_BUILD_PATH_PROBLEM;
36	public static String _WARNING_COMPILATION_PROBLEM;	63	public static String _WARNING_COMPILATION_PROBLEM;
		64	public static String W_COMP_UNIT_OVERWRITE;
37	}	65	}

Lines 14-19 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/messages.properties (-1 / +29 lines)
14		14
15	E_CODEGEN_PACK_DIAG = A problem was found with the package name: {0}. The code for this test suite cannot be generated until you adjust the package name.	15	E_CODEGEN_PACK_DIAG = A problem was found with the package name: {0}. The code for this test suite cannot be generated until you adjust the package name.
16	E_CODEGEN_CLASS_DIAG = A problem was found with the class name: {0}. The code for this test suite cannot be generated until you adjust the class name.	16	E_CODEGEN_CLASS_DIAG = A problem was found with the class name: {0}. The code for this test suite cannot be generated until you adjust the class name.
		17	E_COMP_UNIT_READ_ONLY=Compilation unit {0} is read-only
17	E_CODEGEN_CLOSED_PROJECT= The source folder: {0} belongs to a closed project. The code for this test cannot be generated until the project is opened.	18	E_CODEGEN_CLOSED_PROJECT= The source folder: {0} belongs to a closed project. The code for this test cannot be generated until the project is opened.
18	E_CODEGEN_NO_SRCFOLDER = The test suite does not specify a source folder.	19	E_CODEGEN_NO_SRCFOLDER = The test suite does not specify a source folder.
19		20
Lines 22-25 Link Here
22	VALIDATION_NO_HOST_NAME_ERROR = No host name found	23	VALIDATION_NO_HOST_NAME_ERROR = No host name found
23	VALIDATION_BAD_ROOTDIR_ERROR_ = {0}\nThis value for ROOTDIR does not match existing directory on the specified host: {1}	24	VALIDATION_BAD_ROOTDIR_ERROR_ = {0}\nThis value for ROOTDIR does not match existing directory on the specified host: {1}
24	_WARNING_BUILD_PATH_PROBLEM = Java build path errors exist in enclosing project: {0}.	25	_WARNING_BUILD_PATH_PROBLEM = Java build path errors exist in enclosing project: {0}.
25	_WARNING_COMPILATION_PROBLEM = Compilation errors exist in enclosing project: {0}.	26	_WARNING_COMPILATION_PROBLEM = Compilation errors exist in enclosing project: {0}.
		27	CREATE_PACKAGE=Create package {0}
		28	CREATE_CONTAINER=Create container {0}
		29	NO_SOURCE_FOLDER=Source folder doesn't exist
		30	NOT_A_SOURCE_FOLDER=Package fragment root is not a source folder
		31	NOT_IN_JAVA_PROJECT=Container {0} does not belong to a Java project
		32	ASSOCIATE_TEST_TO_SOURCE=Associate test {0} to source {1}
		33	NO_FILE=File does not exist
		34	READ_ONLY_FILE=File is read-only
		35	DELETING_FILE=Deleting file
		36	DELETE_FILE=Delete file {0}
		37	DEFINE_SOURCE_FOLDER=Define {0} as a source folder
		38	RESOURCE_NOT_ACCESSIBLE=Resource {0} is not accessible
		39	RENAME_COMPILATION_UNIT=Rename compilation unit {0} to {1}
		40	ADJUST_CLASSPATH=Adjust classpath for project {0}
		41	PROJECT_NOT_ACCESSIBLE=Project '{0}' is not accessible
		42	GENERATE_FILE=Generate file {0}
		43	GENERATE_CODE=Generate code
		44	UNKNOWN_LOCATION=Unknown location for file
		45	GENERATING_FILE=Generating file
		46	GENERIC_GENERATOR=Generic TPTP code generator
		47	SETUP_CONTEXT=Setup context
		48	UPDATE_CODE=Update code
		49	MOVE_RENAME_COMPILATION_UNIT=Move compilation unit {0} to package {1} and rename it to {2}
		50	MOVE_COMPILATION_UNIT=Move compilation unit {0} to package {1}
		51	W_COMP_UNIT_OVERWRITE=Compilation unit {0} will be overwritten
		52	DEFAULT_PACKAGE=(default package)
		53	JavaGenerator_W_COMP_UNIT_UNSAVED_CHANGES=Compilation unit {0} has unsaved changes. Code update may be unaccurate.

Lines 11-70 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/JavaGenerator.java (-81 / +233 lines)
11	**********************************************************************/	11	**********************************************************************/
12	package org.eclipse.hyades.test.tools.core.internal.common.codegen;	12	package org.eclipse.hyades.test.tools.core.internal.common.codegen;
13		13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.Collection;	14	import java.util.Collection;
17	import java.util.Collections;	15	import java.util.Collections;
18	import java.util.HashSet;	16	import java.util.HashSet;
19	import java.util.Iterator;	17	import java.util.Iterator;
20	import java.util.List;
21	import java.util.Set;	18	import java.util.Set;
22		19
23	import org.eclipse.core.resources.IContainer;	20	import org.eclipse.core.resources.IContainer;
24	import org.eclipse.core.resources.IFile;	21	import org.eclipse.core.resources.IFile;
25	import org.eclipse.core.resources.IProject;	22	import org.eclipse.core.resources.IProject;
26	import org.eclipse.core.resources.IResource;
27	import org.eclipse.core.resources.ResourcesPlugin;	23	import org.eclipse.core.resources.ResourcesPlugin;
28	import org.eclipse.core.runtime.CoreException;	24	import org.eclipse.core.runtime.CoreException;
29	import org.eclipse.core.runtime.IPath;	25	import org.eclipse.core.runtime.IPath;
30	import org.eclipse.core.runtime.IProgressMonitor;	26	import org.eclipse.core.runtime.IProgressMonitor;
31	import org.eclipse.core.runtime.IStatus;	27	import org.eclipse.core.runtime.IStatus;
		28	import org.eclipse.core.runtime.OperationCanceledException;
32	import org.eclipse.core.runtime.Path;	29	import org.eclipse.core.runtime.Path;
33	import org.eclipse.core.runtime.Status;
34	import org.eclipse.core.runtime.SubProgressMonitor;	30	import org.eclipse.core.runtime.SubProgressMonitor;
35	import org.eclipse.hyades.models.common.facades.behavioral.ITestCase;	31	import org.eclipse.hyades.models.common.facades.behavioral.ITestCase;
36	import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;	32	import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
37	import org.eclipse.hyades.test.tools.core.CorePlugin;
38	import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;	33	import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
39	import org.eclipse.jdt.core.IClasspathEntry;	34	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.AdjustSourceContainerChange;
		35	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.CreatePackageFragmentChange;
		36	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.MoveCompilationUnitChange;
		37	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.PotentialChange;
		38	import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.ProjectAdjustChange;
		39	import org.eclipse.jdt.core.ICompilationUnit;
		40	import org.eclipse.jdt.core.IJavaElement;
40	import org.eclipse.jdt.core.IJavaProject;	41	import org.eclipse.jdt.core.IJavaProject;
		42	import org.eclipse.jdt.core.IPackageFragment;
		43	import org.eclipse.jdt.core.IPackageFragmentRoot;
41	import org.eclipse.jdt.core.JavaConventions;	44	import org.eclipse.jdt.core.JavaConventions;
42	import org.eclipse.jdt.core.JavaCore;	45	import org.eclipse.jdt.core.JavaCore;
		46	import org.eclipse.ltk.core.refactoring.Change;
		47	import org.eclipse.ltk.core.refactoring.CompositeChange;
		48	import org.eclipse.ltk.core.refactoring.NullChange;
		49	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
43	import org.eclipse.osgi.util.NLS;	50	import org.eclipse.osgi.util.NLS;
44		51
45	/**	52	/**
46	* @author marcelop	53	* Abstract Java code generator.
47	* @author jcanches	54	* <p>Although this abstract class does not implement any code generation
		55	* or code update, it provides additional features for generating java code, and also
		56	* makes additional assumptions about the test suite behavior model.</p>
		57	* <p>Sub-classes must implement {@link Generator#generateCode(IProgressMonitor)}, and
		58	* need to redefine {@link #createSourceUpdateChange(SubProgressMonitor)} if code update
		59	* is desired.</p>
		60	* <p>Sub-classes may also redefine {@link #computeTestMethodNames(ITestSuite, boolean, Helper)},
		61	* and extend {@link #createAdjustProjectClasspathChange(IProgressMonitor)},
		62	* {@link #createPreCodegenerationChange(IProgressMonitor)},
		63	* {@link Generator#createPostCodegenerationChange(IProgressMonitor)}, and all conditions
		64	* checking methods.</p>
		65	* @author marcelop, jcanches
48	* @since 1.0.1	66	* @since 1.0.1
49	*/	67	*/
50	abstract public class JavaGenerator extends Generator {	68	abstract public class JavaGenerator extends Generator {
51		69
52	private IProjectDependencyUpdater projectDependencyUpdater;	70	private IProjectDependencyUpdater projectDependencyUpdater;
53		71
54	protected JavaGenerator(IProjectDependencyUpdater updater) {	72	/**
		73	* Creates a JavaGenerator for a Java test suite.
		74	* @param testSuite
		75	* @param updater A Project dependency updater that will perform project
		76	* adjustment to comply with additional classpath requirements.
		77	*/
		78	protected JavaGenerator(ITestSuite testSuite, IProjectDependencyUpdater updater) {
		79	super(testSuite);
55	this.projectDependencyUpdater = updater;	80	this.projectDependencyUpdater = updater;
56	}	81	}
57		82
58	protected void adjustProjectClasspath(ITestSuite testSuite, IProject project, IProgressMonitor monitor) throws CoreException {	83	/**
59	Collection dependentProjects = getDependentProjects(testSuite, project);	84	* Creates the change that adjusts the project classpath.
60	for(Iterator it = dependentProjects.iterator(); it.hasNext(); ) {	85	* <p>This implementation creates a change that invokes the generator's project
61	projectDependencyUpdater.addRequiredProject((IProject)it.next());	86	* dependency updater.</p>
		87	* <p>Sub-classes may extend or redefine this implementation.</p>
		88	* @param monitor
		89	* @return
		90	* @throws CoreException
		91	*/
		92	protected Change createAdjustProjectClasspathChange(IProgressMonitor monitor) throws CoreException {
		93	monitor.beginTask("", 1); //$NON-NLS-1$
		94	try {
		95	IProject project = getFileHandle(getTestSuite()).getProject();
		96	Collection dependentProjects = getDependentProjects(getTestSuite(), project);
		97	for(Iterator it = dependentProjects.iterator(); it.hasNext(); ) {
		98	projectDependencyUpdater.addRequiredProject((IProject)it.next());
		99	}
		100	if (!projectDependencyUpdater.previewAdjustProject(project).isEmpty()) {
		101	monitor.worked(1);
		102	return new ProjectAdjustChange(projectDependencyUpdater, project);
		103	} else {
		104	monitor.worked(1);
		105	return null;
		106	}
		107	} finally {
		108	monitor.done();
		109	}
		110	}
		111
		112	protected IPackageFragmentRoot getPackageFragmentRoot(ITestSuite ts) {
		113	IContainer container = getSourceContainerHandle(ts);
		114	IJavaElement javaElement = JavaCore.create(container);
		115	if (javaElement instanceof IJavaProject) {
		116	IJavaProject jproject = (IJavaProject)javaElement;
		117	return jproject.getPackageFragmentRoot(container);
		118	} else if (javaElement instanceof IPackageFragmentRoot) {
		119	return (IPackageFragmentRoot)javaElement;
		120	}
		121	return null;
		122	}
		123
		124	protected IPackageFragment getPackageFragment(ITestSuite ts) {
		125	IPackageFragmentRoot root = getPackageFragmentRoot(ts);
		126	if (root == null) return null;
		127	return root.getPackageFragment(getPackageName(ts));
		128	}
		129
		130	protected ICompilationUnit getCompilationUnit(ITestSuite ts) {
		131	IPackageFragment pack = getPackageFragment(ts);
		132	if (pack != null) {
		133	return pack.getCompilationUnit(getClassName(ts) + ".java"); //$NON-NLS-1$
62	}	134	}
63	projectDependencyUpdater.adjustProject(project, monitor);	135	return null;
64	}	136	}
65		137
66	protected String getPackageName(ITestSuite testSuite) {	138	/**
67	String cls = testSuite.getImplementor().getResource();	139	* Returns the package name that the generated class must belong to.
		140	* @return A Java package name.
		141	*/
		142	protected String getPackageName(ITestSuite ts) {
		143	String cls = ts.getImplementor().getResource();
68	String packageName;	144	String packageName;
69	int index = cls.lastIndexOf('.');	145	int index = cls.lastIndexOf('.');
70	if (index == -1) {	146	if (index == -1) {
Lines 75-82 Link Here
75	return packageName;	151	return packageName;
76	}	152	}
77		153
78	protected String getClassName(ITestSuite testSuite) {	154	/**
79	String cls = testSuite.getImplementor().getResource();	155	* Returns the class name of the generated class.
		156	* @return
		157	*/
		158	protected String getClassName(ITestSuite ts) {
		159	String cls = ts.getImplementor().getResource();
80	String className;	160	String className;
81	int index = cls.lastIndexOf('.');	161	int index = cls.lastIndexOf('.');
82	if (index == -1) {	162	if (index == -1) {
Lines 87-151 Link Here
87	return className;	167	return className;
88	}	168	}
89		169
90	protected void doGenerateFile(ITestSuite testSuite, IContainer sourceContainer, IFile file, IProgressMonitor monitor)	170	/**
91	throws Exception	171	* In addition to its super implementation, this implementation creates a change that ensures
		172	* that the source container is a source folder, creates the package, and adjusts the project
		173	* classpath if necessary.
		174	*/
		175	protected Change createPreCodegenerationChange(IProgressMonitor monitor) throws CoreException
92	{	176	{
93	monitor.beginTask("", 10); //$NON-NLS-1$	177	monitor.beginTask("", 10); //$NON-NLS-1$
94	try {	178	try {
95	String packageName = getPackageName(testSuite);	179	CompositeChange change = new CompositeChange(CommonPluginMessages.SETUP_CONTEXT);
96	adjustSourceContainer(sourceContainer, packageName, new SubProgressMonitor(monitor, 1));	180	addPotentialChange(super.createPreCodegenerationChange(monitor), change);
97	adjustProjectClasspath(testSuite, file.getProject(), new SubProgressMonitor(monitor, 4));	181	addPotentialChange(createAdjustSourceContainerChange(), change);
98	generateFile(testSuite, file, new SubProgressMonitor(monitor, 5));	182	addPotentialChange(createCreatePackageChange(), change);
		183	addPotentialChange(createAdjustProjectClasspathChange(new SubProgressMonitor(monitor, 1)), change);
		184	return packCompositeChange(change);
99	} finally {	185	} finally {
100	monitor.done();	186	monitor.done();
101	}	187	}
102	}	188	}
		189
		190	/**
		191	* Helper method to create a change that makes sure that the source container is a java
		192	* source folder.
		193	* @return
		194	*/
		195	final protected Change createAdjustSourceContainerChange() {
		196	PotentialChange change = new AdjustSourceContainerChange(getSourceContainerHandle(getTestSuite()));
		197	if (change.hasEffect()) return change;
		198	else return new NullChange();
		199	}
		200
		201	/**
		202	* Helper method to create a change that creates the package, if necessary.
		203	*/
		204	final protected Change createCreatePackageChange() {
		205	IJavaProject jproject = JavaCore.create(getSourceContainerHandle(getTestSuite()).getProject());
		206	IPackageFragmentRoot sourceFolder = jproject.getPackageFragmentRoot(getSourceContainerHandle(getTestSuite()));
		207	PotentialChange change = new CreatePackageFragmentChange(sourceFolder, getPackageName(getTestSuite()));
		208	if (change.hasEffect()) return change;
		209	else return new NullChange();
		210	}
103		211
104	protected void doUpdateFile(ITestSuite testSuite, IContainer sourceContainer, IFile file, IProgressMonitor monitor) throws Exception {	212	protected final Change createUpdateChange(IFile file, IProgressMonitor monitor) throws CoreException, UnsupportedOperationException {
105	monitor.beginTask("", 2); //$NON-NLS-1$	213	monitor.beginTask("", 2); //$NON-NLS-1$
106	try {	214	try {
107	adjustProjectClasspath(testSuite, sourceContainer.getProject(), new SubProgressMonitor(monitor, 1));	215	Change sourceUpdateChange = createSourceUpdateChange(file, new SubProgressMonitor(monitor, 1));
108	updateFile(testSuite, file, new SubProgressMonitor(monitor, 1));	216	CompositeChange change = new CompositeChange(CommonPluginMessages.UPDATE_CODE);
		217	addPotentialChange(createAdjustProjectClasspathChange(new SubProgressMonitor(monitor, 1)), change);
		218	addPotentialChange(sourceUpdateChange, change);
		219	addPotentialChange(createCreatePackageChange(), change);
		220	addPotentialChange(createMoveCompilationUnitChange(), change);
		221	addPotentialChange(createPostCodegenerationChange(new SubProgressMonitor(monitor, 1)), change);
		222	change.markAsSynthetic();
		223	return packCompositeChange(change);
109	} finally {	224	} finally {
110	monitor.done();	225	monitor.done();
111	}	226	}
112	}	227	}
		228
		229	/**
		230	* Creates a move compilation unit change, if necessary (i.e. if the classes in the
		231	* previous and in the current versions of the model are different).
		232	* @return
		233	*/
		234	private Change createMoveCompilationUnitChange() {
		235	ITestSuite previous = getRepositoryTestSuite();
		236	if (previous != null) {
		237	IFile file = getFileHandle(previous);
		238	IFile newFile = getFileHandle(getTestSuite());
		239	if (!newFile.equals(file)) {
		240	// Change destination
		241	if (file.exists()) {
		242	ICompilationUnit cu = JavaCore.createCompilationUnitFrom(file);
		243	if (cu.exists()) {
		244	IPackageFragment newPackage = getPackageFragment(getTestSuite());
		245	return new MoveCompilationUnitChange(cu, newPackage, newFile.getName());
		246	}
		247	}
		248	}
		249	}
		250	return null;
		251	}
113		252
114	public IStatus validate(ITestSuite testSuite) {	253	/**
115	IStatus status;	254	* Creates the source update change. This implementation throws a {@link UnsupportedOperationException}.
116		255	* Sub-classes need to redefine this method in order to be code-update-capable.
117	// Super validation	256	* @file The file to update. This is not always equal to getFileHandle(), when there
118	status = super.validate(testSuite);	257	* is a source file move involved during the generation.
119	if (status.getSeverity() != IStatus.OK) return status;	258	* @param monitor A progress monitor
120		259	* @return
121	// Package name	260	* @throws CoreException, UnsupportedOperationException
122	String packageName = getPackageName(testSuite);	261	*/
123	if (packageName.length() > 0) {	262	protected Change createSourceUpdateChange(IFile file, SubProgressMonitor monitor) throws CoreException, UnsupportedOperationException {
124	status = JavaConventions.validatePackageName(packageName);	263	throw new UnsupportedOperationException();
125	if (status.getSeverity() != IStatus.OK) {	264	}
126	if (status.getSeverity() == IStatus.ERROR) {	265
		266	/**
		267	* In addition to its super implementation, this implementation checks that the package name
		268	* and class name are valid.
		269	*/
		270	public RefactoringStatus checkInitialConditions(IProgressMonitor monitor) throws CoreException, OperationCanceledException {
		271	monitor.beginTask("", 4); //$NON-NLS-1$
		272	try {
		273	// Super validation
		274	RefactoringStatus status = super.checkInitialConditions(new SubProgressMonitor(monitor, 2));
		275
		276	// Package name
		277	String packageName = getPackageName(getTestSuite());
		278	if (packageName.length() > 0) {
		279	IStatus st = JavaConventions.validatePackageName(packageName);
		280	if (st.getSeverity() != IStatus.OK) {
		281	if (st.getSeverity() == IStatus.ERROR) {
		282	// Replace the diagnosis of JDT with something more explicit
		283	status.addFatalError(NLS.bind(CommonPluginMessages.E_CODEGEN_PACK_DIAG, st.getMessage()));
		284	}
		285	}
		286	}
		287	monitor.worked(1);
		288
		289	// Class name
		290	String className = getClassName(getTestSuite());
		291	IStatus st = JavaConventions.validateJavaTypeName(className);
		292	if (st.getSeverity() != IStatus.OK) {
		293	if (st.getSeverity() == IStatus.ERROR) {
127	// Replace the diagnosis of JDT with something more explicit	294	// Replace the diagnosis of JDT with something more explicit
128	return new Status(status.getSeverity(), CorePlugin.PLUGIN_ID, 0, NLS.bind(CommonPluginMessages.E_CODEGEN_PACK_DIAG, status.getMessage()), null);	295	status.addFatalError(NLS.bind(CommonPluginMessages.E_CODEGEN_CLASS_DIAG, st.getMessage()));
129	}	296	}
130	return status;
131	}	297	}
132	}	298	monitor.worked(1);
133		299
134	// Class name	300	ITestSuite previous = getRepositoryTestSuite();
135	String className = getClassName(testSuite);	301	ICompilationUnit cu;
136	status = JavaConventions.validateJavaTypeName(className);	302	if (previous != null) {
137	if (status.getSeverity() != IStatus.OK) {	303	cu = getCompilationUnit(previous);
138	if (status.getSeverity() == IStatus.ERROR) {	304	} else {
139	// Replace the diagnosis of JDT with something more explicit	305	cu = getCompilationUnit(getTestSuite());
140	return new Status(status.getSeverity(), CorePlugin.PLUGIN_ID, 0, NLS.bind(CommonPluginMessages.E_CODEGEN_CLASS_DIAG, status.getMessage()), null);	306	}
		307	if (cu != null && cu.hasUnsavedChanges()) {
		308	status.addError(NLS.bind(CommonPluginMessages.JavaGenerator_W_COMP_UNIT_UNSAVED_CHANGES, cu.getElementName()));
141	}	309	}
142	return status;	310	return status;
		311	} finally {
		312	monitor.done();
143	}	313	}
144
145	// Otherwise OK
146	return Status.OK_STATUS;
147	}	314	}
148		315
		316	/**
		317	* Computes the names of the test methods associated to the test cases of the specified test
		318	* suite. Test methods names should be typically stored in the model.
		319	* @param testSuite
		320	* @param isExternalBehavior
		321	* @param helper
		322	* @see Helper#setTestMethodName(ITestCase, String)
		323	*/
149	protected void computeTestMethodNames(ITestSuite testSuite, boolean isExternalBehavior, Helper helper) {	324	protected void computeTestMethodNames(ITestSuite testSuite, boolean isExternalBehavior, Helper helper) {
150	Iterator it = testSuite.getITestCases().iterator();	325	Iterator it = testSuite.getITestCases().iterator();
151	while (it.hasNext()) {	326	while (it.hasNext()) {
Lines 155-184 Link Here
155	}	330	}
156	}	331	}
157		332
158	public IFile getFileHandle(ITestSuite testSuite)	333	public IFile getFileHandle(ITestSuite ts) {
159	{	334	IContainer sourceContainer = getSourceContainerHandle(ts);
160	IContainer sourceContainer = getSourceContainerHandle(testSuite);	335	return sourceContainer.getFile(new Path(ts.getImplementor().getResource().replace('.','/') + ".java")); //$NON-NLS-1$
161	return sourceContainer.getFile(new Path(testSuite.getImplementor().getResource().replace('.','/') + ".java")); //$NON-NLS-1$
162	}	336	}
163		337
164	protected void adjustSourceContainer(IContainer sourceContainer, String packageName, IProgressMonitor monitor)
165	throws Exception
166	{
167	IJavaProject javaProject = JavaCore.create(sourceContainer.getProject());
168	if(sourceContainer.getType() == IResource.FOLDER)
169	{
170	if(!javaProject.isOnClasspath(sourceContainer))
171	{
172	IClasspathEntry entry = JavaCore.newSourceEntry(sourceContainer.getFullPath());
173	List entries = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
174	entries.add(1, entry);
175	javaProject.setRawClasspath((IClasspathEntry[])entries.toArray(new IClasspathEntry[entries.size()]), monitor);
176	}
177	}
178
179	javaProject.getPackageFragmentRoot(sourceContainer).createPackageFragment(packageName, true, monitor);
180	}
181
182	protected static Collection getDependentProjects(ITestSuite testSuite, IProject project)	338	protected static Collection getDependentProjects(ITestSuite testSuite, IProject project)
183	{	339	{
184	if((testSuite.getIReferencedSuites() == null) \|\| (testSuite.getIReferencedSuites().isEmpty()))	340	if((testSuite.getIReferencedSuites() == null) \|\| (testSuite.getIReferencedSuites().isEmpty()))
Lines 203-210 Link Here
203	return entries;	359	return entries;
204	}	360	}
205		361
206	public IProjectDependencyUpdater getProjectDependencyUpdater() {
207	return projectDependencyUpdater;
208	}
209
210	}	362	}

Lines 227-231 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/modelsync/JUnitProjectBuilder.java (+12 lines)
227	d.setBuildSpec(newCommands);	227	d.setBuildSpec(newCommands);
228	project.setDescription(d, null);	228	project.setDescription(d, null);
229	}	229	}
		230
		231	public static boolean isBuilderInstalled(IProject project) throws CoreException {
		232	IProjectDescription d = project.getDescription();
		233	ICommand[] buildSpec = d.getBuildSpec();
		234	int found = 0;
		235	for (int i = 0; i < buildSpec.length; i++) {
		236	if (buildSpec[i].getBuilderName().equals(BUILDER_ID)) {
		237	return true;
		238	}
		239	}
		240	return false;
		241	}
230		242
231	}	243	}

Lines 65-79 Link Here

(-)META-INF/MANIFEST.MF (-4 / +5 lines)
65	org.eclipse.tptp.test.manual.runner.ui.internal.util	65	org.eclipse.tptp.test.manual.runner.ui.internal.util
66	Require-Bundle: org.eclipse.hyades.test.core;bundle-version="[4.2.0,5.0.0)",	66	Require-Bundle: org.eclipse.hyades.test.core;bundle-version="[4.2.0,5.0.0)",
67	org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",	67	org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
68	org.eclipse.core.resources;resolution:=optional;bundle-version="[3.2.0,4.0.0)",	68	org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
69	org.eclipse.jface.text;bundle-version="[3.2.0,4.0.0)",	69	org.eclipse.jface.text;bundle-version="[3.2.0,4.0.0)",
70	org.eclipse.jdt.core;resolution:=optional;bundle-version="[3.2.0,4.0.0)",	70	org.eclipse.jdt.core;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
71	org.eclipse.tptp.platform.models;bundle-version="[4.2.0,5.0.0)",	71	org.eclipse.tptp.platform.models;bundle-version="[4.2.0,5.0.0)",
72	org.eclipse.hyades.execution;bundle-version="[4.2.0,5.0.0)",	72	org.eclipse.hyades.execution;bundle-version="[4.2.0,5.0.0)",
73	org.eclipse.hyades.logging.core;bundle-version="[4.2.0,5.0.0)",	73	org.eclipse.hyades.logging.core;bundle-version="[4.2.0,5.0.0)",
74	com.ibm.icu;bundle-version="[3.4.3,4.0.0)",	74	com.ibm.icu;bundle-version="[3.4.3,4.0.0)",
75	org.eclipse.debug.core;resolution:=optional;bundle-version="[3.2.0,4.0.0)",	75	org.eclipse.debug.core;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
76	org.eclipse.pde.core;bundle-version="[3.2.0,4.0.0)",	76	org.eclipse.pde.core;bundle-version="[3.2.0,4.0.0)",
77	org.eclipse.ui;resolution:=optional;bundle-version="[3.2.0,4.0.0)",	77	org.eclipse.ltk.core.refactoring;bundle-version="[3.2.0,4.0.0)";visibility:=reexport,
		78	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)";resolution:=optional,
78	org.junit;bundle-version="[3.8.1,4.0.0)"	79	org.junit;bundle-version="[3.8.1,4.0.0)"
79	Eclipse-LazyStart: true	80	Eclipse-LazyStart: true

Lines 14-19 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/plugin/codegen/PluginProjectDependencyUpdater.java (+19 lines)
14		14
15	import java.io.File;	15	import java.io.File;
16	import java.util.Collection;	16	import java.util.Collection;
		17	import java.util.Collections;
17	import java.util.HashSet;	18	import java.util.HashSet;
18	import java.util.Iterator;	19	import java.util.Iterator;
19	import java.util.jar.JarFile;	20	import java.util.jar.JarFile;
Lines 119-123 Link Here
119	}	120	}
120	}	121	}
121		122
		123	public Collection previewAdjustProject(IProject project) {
		124	IPluginModelBase pluginModel = findProjectPluginModel(project);
		125	if (pluginModel != null) {
		126	HashSet result = new HashSet();
		127	IPluginBase plugin = pluginModel.getPluginBase(/CreateIfMissing/false);
		128	Iterator it = requiredPlugins.iterator();
		129	boolean changed = false;
		130	while (it.hasNext()) {
		131	String pluginId = (String) it.next();
		132	if (findPluginImport(plugin, pluginId) == null) {
		133	result.add(pluginId);
		134	}
		135	}
		136	return result;
		137	}
		138	return Collections.EMPTY_SET;
		139	}
		140
122		141
123	}	142	}

Added Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/changes/MoveCompilationUnitChange.java (+130 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;
12
13	import org.eclipse.core.resources.IResource;
14	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.core.runtime.IProgressMonitor;
16	import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
17	import org.eclipse.jdt.core.ICompilationUnit;
18	import org.eclipse.jdt.core.IPackageFragment;
19	import org.eclipse.ltk.core.refactoring.Change;
20	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
21	import org.eclipse.osgi.util.NLS;
22
23	/**
24	* Changes that moves a compilation unit (to a new package and/or a new name).
25	* @author jcanches
26	* @since 4.3
27	*/
28	public class MoveCompilationUnitChange extends Change {
29
30	private boolean fUndoable;
31	private long fStampToRestore;
32	private ICompilationUnit compilationUnit;
33	private IPackageFragment newPackage;
34	private String newName;
35	private boolean isPackageChanged;
36	private boolean isClassnameChanged;
37
38	public MoveCompilationUnitChange(ICompilationUnit cu, IPackageFragment newPackage, String newName){
39	this(cu, newPackage, newName, IResource.NULL_STAMP);
40	}
41
42	private MoveCompilationUnitChange(ICompilationUnit cu, IPackageFragment newPackage, String newName, long stampToRestore) {
43	this.compilationUnit = cu;
44	if (newPackage == null) {
45	newPackage = (IPackageFragment)compilationUnit.getParent();
46	} else {
47	this.newPackage = newPackage;
48	}
49	if (newName == null) {
50	this.newName = compilationUnit.getElementName();
51	} else {
52	this.newName = newName;
53	}
54	fStampToRestore= stampToRestore;
55	isPackageChanged = !compilationUnit.getParent().equals(newPackage);
56	isClassnameChanged = !this.newName.equals(compilationUnit.getElementName());
57	}
58
59	public String getName() {
60	if (isPackageChanged && isClassnameChanged) {
61	return NLS.bind(CommonPluginMessages.MOVE_RENAME_COMPILATION_UNIT,
62	new Object[] { compilationUnit.getElementName(), getPackageName(newPackage), newName });
63	}
64	if (isPackageChanged) {
65	return NLS.bind(CommonPluginMessages.MOVE_COMPILATION_UNIT,
66	new Object[] { compilationUnit.getElementName(), getPackageName(newPackage) });
67	}
68	if (isClassnameChanged) {
69	return NLS.bind(CommonPluginMessages.RENAME_COMPILATION_UNIT,
70	new Object[] { compilationUnit.getElementName(), newName});
71	}
72	return "Invalid change"; //$NON-NLS-1$
73	}
74
75	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException {
76	RefactoringStatus status = new RefactoringStatus();
77	if (compilationUnit.isReadOnly()) {
78	status.addFatalError(NLS.bind(CommonPluginMessages.E_COMP_UNIT_READ_ONLY, compilationUnit.getElementName()));
79	}
80	if (newPackage.getCompilationUnit(newName).exists()) {
81	status.addWarning(NLS.bind(CommonPluginMessages.W_COMP_UNIT_OVERWRITE, compilationUnit.getElementName()));
82	}
83	return status;
84	}
85
86	public Change perform(IProgressMonitor pm) throws CoreException {
87	// get current modification stamp
88	long currentStamp= IResource.NULL_STAMP;
89	IResource resource= compilationUnit.getResource();
90	if (resource != null) {
91	currentStamp= resource.getModificationStamp();
92	}
93
94	fUndoable= ! newPackage.getCompilationUnit(newName).exists();
95	String oldName = compilationUnit.getElementName();
96	IPackageFragment oldPackage = (IPackageFragment) compilationUnit.getParent();
97
98	// perform the move and restore modification stamp
99	compilationUnit.move(newPackage, null, newName, true, pm);
100	ICompilationUnit moved= newPackage.getCompilationUnit(newName);
101	if (fStampToRestore != IResource.NULL_STAMP) {
102	IResource movedResource= moved.getResource();
103	if (movedResource != null) {
104	movedResource.revertModificationStamp(fStampToRestore);
105	}
106	}
107
108	if (fUndoable) {
109	return new MoveCompilationUnitChange(moved, oldPackage, oldName, currentStamp);
110	} else {
111	return null;
112	}
113	}
114
115	static String getPackageName(IPackageFragment pack) {
116	if (pack.isDefaultPackage())
117	return CommonPluginMessages.DEFAULT_PACKAGE;
118	else
119	return pack.getElementName();
120	}
121
122	public Object getModifiedElement() {
123	return compilationUnit;
124	}
125
126	public void initializeValidationData(IProgressMonitor pm) {
127	// NOP
128	}
129
130	}

Added Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/changes/CompilationUnitChange.java (+125 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;
12
13	import org.eclipse.core.resources.IFile;
14	import org.eclipse.core.runtime.Assert;
15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.SubProgressMonitor;
18	import org.eclipse.jdt.core.ICompilationUnit;
19	import org.eclipse.jface.text.IDocument;
20	import org.eclipse.ltk.core.refactoring.TextFileChange;
21
22	/**
23	* Change that modifies the content of a compilation unit.
24	* Copied from org.eclipse.jdt.internal.corext.refactoring.changes.CompilationUnitChange.
25	* @author jcanches
26	* @since 4.3
27	*/
28	public class CompilationUnitChange extends TextFileChange {
29
30	private ICompilationUnit fCUnit;
31	private boolean destructive;
32
33	/**
34	* Creates a new <code>CompilationUnitChange</code>.
35	*
36	* @param name the change's name mainly used to render the change in the UI
37	* @param cunit the compilation unit this text change works on
38	* @param destructive Whether this change contains destructive changes (i.e. applying it
39	* will delete some existing code)
40	*/
41	public CompilationUnitChange(String name, ICompilationUnit cunit, boolean destructive) {
42	super(name, getFile(cunit));
43	Assert.isNotNull(cunit);
44	fCUnit= cunit;
45	setTextType("java"); //$NON-NLS-1$
46	this.destructive = destructive;
47	}
48
49	private static IFile getFile(ICompilationUnit cunit) {
50	return (IFile) cunit.getResource();
51	}
52
53	/* non java-doc
54	* Method declared in IChange.
55	*/
56	public Object getModifiedElement(){
57	return fCUnit;
58	}
59
60	/**
61	* Returns the compilation unit this change works on.
62	*
63	* @return the compilation unit this change works on
64	*/
65	public ICompilationUnit getCompilationUnit() {
66	return fCUnit;
67	}
68
69	/**
70	* {@inheritDoc}
71	*/
72	protected IDocument acquireDocument(IProgressMonitor pm) throws CoreException {
73	pm.beginTask("", 2); //$NON-NLS-1$
74	fCUnit.becomeWorkingCopy(null, new SubProgressMonitor(pm, 1));
75	return super.acquireDocument(new SubProgressMonitor(pm, 1));
76	}
77
78	/**
79	* {@inheritDoc}
80	*/
81	protected void releaseDocument(IDocument document, IProgressMonitor pm) throws CoreException {
82	super.releaseDocument(document, pm);
83	try {
84	fCUnit.discardWorkingCopy();
85	} finally {
86	if (!isDocumentAcquired()) {
87	if (fCUnit.isWorkingCopy())
88	fCUnit.reconcile(
89	ICompilationUnit.NO_AST,
90	false /* don't force problem detection */,
91	null /* use primary owner */,
92	null /* no progress monitor */);
93
94	else
95	fCUnit.makeConsistent(pm);
96	}
97	}
98	}
99
100	// /**
101	// * {@inheritDoc}
102	// */
103	// protected Change createUndoChange(UndoEdit edit, ContentStamp stampToRestore) {
104	// try {
105	// return new UndoCompilationUnitChange(getName(), fCUnit, edit, stampToRestore, getSaveMode());
106	// } catch (CoreException e) {
107	// JavaPlugin.log(e);
108	// return null;
109	// }
110	// }
111
112	/**
113	* {@inheritDoc}
114	*/
115	public Object getAdapter(Class adapter) {
116	if (ICompilationUnit.class.equals(adapter))
117	return fCUnit;
118	return super.getAdapter(adapter);
119	}
120
121	public boolean isDestructive() {
122	return destructive;
123	}
124	}
125

Added Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/changes/AdjustSourceContainerChange.java (+100 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: $
8	*
9	* Contributors:
10	* IBM Corporation - initial API and implementation
11	*******************************************************************************/
12
13	package org.eclipse.hyades.test.tools.core.internal.common.codegen.changes;
14
15	import java.util.ArrayList;
16	import java.util.Arrays;
17	import java.util.List;
18
19	import org.eclipse.core.resources.IContainer;
20	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.OperationCanceledException;
24	import org.eclipse.hyades.test.tools.core.internal.common.CommonPluginMessages;
25	import org.eclipse.jdt.core.IClasspathEntry;
26	import org.eclipse.jdt.core.IJavaProject;
27	import org.eclipse.jdt.core.JavaCore;
28	import org.eclipse.ltk.core.refactoring.Change;
29	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
30	import org.eclipse.osgi.util.NLS;
31
32	/**
33	* Change that transforms a folder into a source folder.
34	* @author jcanches
35	* @since 4.3
36	*/
37	public class AdjustSourceContainerChange extends PotentialChange {
38
39	private IContainer container;
40
41	public AdjustSourceContainerChange(IContainer container) {
42	this.container = container;
43	}
44
45	public Object getModifiedElement() {
46	return container;
47	}
48
49	public String getName() {
50	return NLS.bind(CommonPluginMessages.DEFINE_SOURCE_FOLDER, container.getFullPath().toString());
51	}
52
53	public void initializeValidationData(IProgressMonitor pm) {
54	// NOP
55	}
56
57	public RefactoringStatus isValid(IProgressMonitor pm) throws CoreException, OperationCanceledException {
58	pm.beginTask("", 2); //$NON-NLS-1$
59	try {
60	RefactoringStatus status = new RefactoringStatus();
61	if (!container.isAccessible()) {
62	status.addFatalError(NLS.bind(CommonPluginMessages.RESOURCE_NOT_ACCESSIBLE, container.getFullPath().toString()));
63	}
64	pm.worked(1);
65	IJavaProject javaProject = JavaCore.create(container.getProject());
66	if (!javaProject.exists()) {
67	status.addFatalError(NLS.bind(CommonPluginMessages.NOT_IN_JAVA_PROJECT, container.getFullPath().toString()));
68	}
69	pm.worked(1);
70	return status;
71	} finally {
72	pm.done();
73	}
74	}
75
76	public Change perform(IProgressMonitor monitor) throws CoreException {
77	IJavaProject javaProject = JavaCore.create(container.getProject());
78	if(container.getType() == IResource.FOLDER)
79	{
80	if(!javaProject.isOnClasspath(container))
81	{
82	IClasspathEntry entry = JavaCore.newSourceEntry(container.getFullPath());
83	List entries = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
84	entries.add(1, entry);
85	javaProject.setRawClasspath((IClasspathEntry[])entries.toArray(new IClasspathEntry[entries.size()]), monitor);
86	}
87	}
88	return null;
89	}
90
91	public boolean hasEffect() {
92	IJavaProject javaProject = JavaCore.create(container.getProject());
93	if(container.getType() == IResource.FOLDER)
94	{
95	return !javaProject.isOnClasspath(container);
96	}
97	return true;
98	}
99
100	}

Lines 36-44 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/wizard/AdjustSourceInfoPage.java (-5 / +5 lines)
36	*/	36	*/
37	public AdjustSourceInfoPage(IImplementor implementor)	37	public AdjustSourceInfoPage(IImplementor implementor)
38	{	38	{
39	super("AdjustSourceInfoPage");	39	super("AdjustSourceInfoPage"); //$NON-NLS-1$
40	setTitle(ToolsUiPlugin.getString("JAVA_GEN_WTITLE"));	40	setTitle(ToolsUiPlugin.getString("JAVA_GEN_WTITLE")); //$NON-NLS-1$
41	setDescription(ToolsUiPlugin.getString("ADJ_PG_DSC"));	41	setDescription(ToolsUiPlugin.getString("ADJ_PG_DSC")); //$NON-NLS-1$
42		42
43	this.implementor = implementor;	43	this.implementor = implementor;
44	}	44	}
Lines 78-90 Link Here
78	{	78	{
79	if(!JavaConventions.validateIdentifier(sourceInfoViewer.getClassName()).isOK())	79	if(!JavaConventions.validateIdentifier(sourceInfoViewer.getClassName()).isOK())
80	{	80	{
81	setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_CLS_NAME"));	81	setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_CLS_NAME")); //$NON-NLS-1$
82	return false;	82	return false;
83	}	83	}
84		84
85	if(!JavaConventions.validatePackageName(sourceInfoViewer.getPackage()).isOK())	85	if(!JavaConventions.validatePackageName(sourceInfoViewer.getPackage()).isOK())
86	{	86	{
87	setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_PCK_NAME"));	87	setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_PCK_NAME")); //$NON-NLS-1$
88	return false;	88	return false;
89	}	89	}
90		90

Lines 52-59 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/wizard/ProjectAndSourcePage.java (-21 / +21 lines)
52	public class ProjectAndSourcePage	52	public class ProjectAndSourcePage
53	extends WizardPage implements ModifyListener, SelectionListener	53	extends WizardPage implements ModifyListener, SelectionListener
54	{	54	{
55	protected static final String SET_PROJECT = "PROJECT_NAME";	55	protected static final String SET_PROJECT = "PROJECT_NAME"; //$NON-NLS-1$
56	protected static final String SET_SOURCE = "SOURCE_FOLDER_NAME";	56	protected static final String SET_SOURCE = "SOURCE_FOLDER_NAME"; //$NON-NLS-1$
57		57
58	private IImplementor implementor;	58	private IImplementor implementor;
59	private IJavaProject[] javaProjects;	59	private IJavaProject[] javaProjects;
Lines 69-77 Link Here
69	*/	69	*/
70	public ProjectAndSourcePage(IImplementor implementor, IJavaProject[] javaProjects)	70	public ProjectAndSourcePage(IImplementor implementor, IJavaProject[] javaProjects)
71	{	71	{
72	super("ProjectAndSourcePage");	72	super("ProjectAndSourcePage"); //$NON-NLS-1$
73	setTitle(ToolsUiPlugin.getString("JAVA_GEN_WTITLE"));	73	setTitle(ToolsUiPlugin.getString("JAVA_GEN_WTITLE")); //$NON-NLS-1$
74	setDescription(ToolsUiPlugin.getString("JAVA_GEN_LDESC"));	74	setDescription(ToolsUiPlugin.getString("JAVA_GEN_LDESC")); //$NON-NLS-1$
75		75
76	this.implementor = implementor;	76	this.implementor = implementor;
77	this.javaProjects = javaProjects;	77	this.javaProjects = javaProjects;
Lines 103-109 Link Here
103	composite.setLayoutData(GridDataUtil.createFill());	103	composite.setLayoutData(GridDataUtil.createFill());
104		104
105	Label label = new Label(composite, SWT.NONE);	105	Label label = new Label(composite, SWT.NONE);
106	label.setText(ToolsUiPlugin.getString("STR_WB_PROJECT"));	106	label.setText(ToolsUiPlugin.getString("STR_WB_PROJECT")); //$NON-NLS-1$
107		107
108	javaProjectText = new Text(composite, SWT.BORDER \| SWT.SINGLE);	108	javaProjectText = new Text(composite, SWT.BORDER \| SWT.SINGLE);
109	javaProjectText.setLayoutData(GridDataUtil.createHorizontalFill());	109	javaProjectText.setLayoutData(GridDataUtil.createHorizontalFill());
Lines 112-123 Link Here
112	GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);	112	GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
113	gridData.horizontalSpan = 2;	113	gridData.horizontalSpan = 2;
114	selectJavaProjectButton.setLayoutData(gridData);	114	selectJavaProjectButton.setLayoutData(gridData);
115	selectJavaProjectButton.setText(ToolsUiPlugin.getString("STR_WB_BROWSE_BTN"));	115	selectJavaProjectButton.setText(ToolsUiPlugin.getString("STR_WB_BROWSE_BTN")); //$NON-NLS-1$
116	selectJavaProjectButton.addSelectionListener(this);	116	selectJavaProjectButton.addSelectionListener(this);
117	selectJavaProjectButton.setEnabled(javaProjects.length > 0);	117	selectJavaProjectButton.setEnabled(javaProjects.length > 0);
118		118
119	label = new Label(composite, SWT.NONE);	119	label = new Label(composite, SWT.NONE);
120	label.setText(ToolsUiPlugin.getString("STR_WB_SRC_FOLDER"));	120	label.setText(ToolsUiPlugin.getString("STR_WB_SRC_FOLDER")); //$NON-NLS-1$
121		121
122	sourceFolderText = new Text(composite, SWT.BORDER \| SWT.SINGLE);	122	sourceFolderText = new Text(composite, SWT.BORDER \| SWT.SINGLE);
123	sourceFolderText.setLayoutData(GridDataUtil.createHorizontalFill());	123	sourceFolderText.setLayoutData(GridDataUtil.createHorizontalFill());
Lines 127-133 Link Here
127	gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);	127	gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
128	gridData.horizontalSpan = 2;	128	gridData.horizontalSpan = 2;
129	selectSourceFolderButton.setLayoutData(gridData);	129	selectSourceFolderButton.setLayoutData(gridData);
130	selectSourceFolderButton.setText(ToolsUiPlugin.getString("STR_WB_SOURCE_BTN"));	130	selectSourceFolderButton.setText(ToolsUiPlugin.getString("STR_WB_SOURCE_BTN")); //$NON-NLS-1$
131	selectSourceFolderButton.addSelectionListener(this);	131	selectSourceFolderButton.addSelectionListener(this);
132		132
133		133
Lines 173-179 Link Here
173	setPageComplete(false);	173	setPageComplete(false);
174	selectSourceFolderButton.setEnabled(false);	174	selectSourceFolderButton.setEnabled(false);
175	javaProjectText.setEditable(false);	175	javaProjectText.setEditable(false);
176	setErrorMessage(ToolsUiPlugin.getString("NO_JAVA_PRJ"));	176	setErrorMessage(ToolsUiPlugin.getString("NO_JAVA_PRJ")); //$NON-NLS-1$
177	composite.setFocus();	177	composite.setFocus();
178	}	178	}
179		179
Lines 229-242 Link Here
229	String value = javaProjectText.getText();	229	String value = javaProjectText.getText();
230	if(value.trim().length() == 0)	230	if(value.trim().length() == 0)
231	{	231	{
232	setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_EMPTY_PROJECT"));	232	setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_EMPTY_PROJECT")); //$NON-NLS-1$
233	return false;	233	return false;
234	}	234	}
235		235
236	IJavaProject javaProject = getJavaProject(value);	236	IJavaProject javaProject = getJavaProject(value);
237	if(javaProject == null)	237	if(javaProject == null)
238	{	238	{
239	setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_NOT_EXIST_PROJECT"));	239	setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_NOT_EXIST_PROJECT")); //$NON-NLS-1$
240	return false;	240	return false;
241	}	241	}
242		242
Lines 254-266 Link Here
254	value = sourceFolderText.getText();	254	value = sourceFolderText.getText();
255	if(value.trim().length() == 0)	255	if(value.trim().length() == 0)
256	{	256	{
257	setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_EMPTY_FOLDER"));	257	setErrorMessage(ToolsUiPlugin.getString("_ERROR_WIZ_EMPTY_FOLDER")); //$NON-NLS-1$
258	return false;	258	return false;
259	}	259	}
260		260
261	if(!isValidFolderName())	261	if(!isValidFolderName())
262	{	262	{
263	setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_FLD_NME"));	263	setErrorMessage(ToolsUiPlugin.getString("_ERROR_INV_FLD_NME")); //$NON-NLS-1$
264	return false;	264	return false;
265	}	265	}
266	}	266	}
Lines 272-281 Link Here
272	protected boolean isValidFolderName()	272	protected boolean isValidFolderName()
273	{	273	{
274	String folder = getSourceFolder();	274	String folder = getSourceFolder();
275	if(folder.startsWith("/"))	275	if(folder.startsWith("/")) //$NON-NLS-1$
276	return false;	276	return false;
277		277
278	if(folder.endsWith("/"))	278	if(folder.endsWith("/")) //$NON-NLS-1$
279	return false;	279	return false;
280		280
281	return true;	281	return true;
Lines 286-292 Link Here
286	if(sourceFolderText.getEditable())	286	if(sourceFolderText.getEditable())
287	return sourceFolderText.getText().trim().replace('\\', '/');	287	return sourceFolderText.getText().trim().replace('\\', '/');
288		288
289	return "";	289	return ""; //$NON-NLS-1$
290	}	290	}
291		291
292	protected IJavaProject getJavaProject()	292	protected IJavaProject getJavaProject()
Lines 313-320 Link Here
313	{	313	{
314	ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);	314	ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
315	ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), labelProvider);	315	ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), labelProvider);
316	dialog.setTitle(ToolsUiPlugin.getString("TITLE_PROJECT_SELECT"));	316	dialog.setTitle(ToolsUiPlugin.getString("TITLE_PROJECT_SELECT")); //$NON-NLS-1$
317	dialog.setMessage(ToolsUiPlugin.getString("STR_PROJECT_SELECT"));	317	dialog.setMessage(ToolsUiPlugin.getString("STR_PROJECT_SELECT")); //$NON-NLS-1$
318	dialog.setElements(javaProjects);	318	dialog.setElements(javaProjects);
319		319
320	IJavaProject javaProject = getJavaProject(javaProjectText.getText());	320	IJavaProject javaProject = getJavaProject(javaProjectText.getText());
Lines 330-337 Link Here
330	protected Object chooseSourceFolder()	330	protected Object chooseSourceFolder()
331	{	331	{
332	ElementTreeSelectionDialog dialog = TestJavaUtil.createSourceFolderDialog(getShell(), null);	332	ElementTreeSelectionDialog dialog = TestJavaUtil.createSourceFolderDialog(getShell(), null);
333	dialog.setTitle(ToolsUiPlugin.getString("TITLE_SRC_SELECT"));	333	dialog.setTitle(ToolsUiPlugin.getString("TITLE_SRC_SELECT")); //$NON-NLS-1$
334	dialog.setMessage(ToolsUiPlugin.getString("STR_SRC_SELECT"));	334	dialog.setMessage(ToolsUiPlugin.getString("STR_SRC_SELECT")); //$NON-NLS-1$
335		335
336	IJavaProject javaProject = getJavaProject(javaProjectText.getText());	336	IJavaProject javaProject = getJavaProject(javaProjectText.getText());
337	if (javaProject != null)	337	if (javaProject != null)