Attachment #47410 for bug #134254

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




               id="org.eclipse.hyades.test.tools.ui.JUnitTestSuiteOpenCode"/>
      </objectContribution>
   </extension>   
   <extension
         point="org.eclipse.ui.popupMenus">
      <objectContribution
            adaptable="false"
            objectClass="org.eclipse.hyades.test.ui.internal.navigator.proxy.DefaultTestCaseProxyNode"
            id="org.eclipse.hyades.test.tools.ui.JUnitTestCaseContribution">
         <action
               enablesFor="1"
               label="%OPEN_JUNIT_TEST_SUITE_CODE"
               class="org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator.actions.OpenJUnitTestSuiteCodeAction"
               menubarPath="org.eclipse.ui.OpenWithSubMenu"
               id="org.eclipse.hyades.test.tools.ui.JUnitTestCaseOpenCode"/>
      </objectContribution>
   </extension>   
   
<!-- #######################################################################  -->
<!--    Plugin JUnit extensions                                                       -->

Lines 1-6 Link Here

(-).project (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<projectDescription>	2	<projectDescription>
3	<name>org.eclipse.hyades.test.tools.ui</name>	3	<name>org.eclipse.hyades.test.tools.ui_134254</name>
4	<comment></comment>	4	<comment></comment>
5	<projects>	5	<projects>
6	</projects>	6	</projects>

Lines 110-115 Link Here

(-)plugin.properties (+1 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.





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 13-30 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/editor/JUnitEditorExtension.java (-15 / +70 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.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 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-130 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	}
129	}	131	}
130	// Perform the save	132	// Perform the save
Lines 133-136 Link Here
133	monitor.done();	135	monitor.done();
134	}	136	}
135	}	137	}
		138
		139	private boolean performBatchChange(Change change) {
		140	try {
		141	change.initializeValidationData(new NullProgressMonitor());
		142	if (change.isValid(new NullProgressMonitor()).isOK()) {
		143	change.perform(new NullProgressMonitor());
		144	return true;
		145	}
		146	return false;
		147	} catch (OperationCanceledException e) {
		148	return false;
		149	} catch (CoreException e) {
		150	ToolsUiPlugin.logError(e);
		151	return false;
		152	}
		153	}
		154
		155	protected boolean performChange(Refactoring refactoring) {
		156	Preferences prefs = ToolsUiPlugin.getDefault().getPluginPreferences();
		157	int previewPref = prefs.getInt(JUnitPreferences.UPDATE_PREVIEW_MODE);
		158	boolean showWizard = previewPref != JUnitPreferences.PREVIEW_NEVER;
		159	Change change = null;
		160	try {
		161	RefactoringStatus status = refactoring.checkAllConditions(new NullProgressMonitor());
		162	if (status.hasEntries()) {
		163	// If there's something that the user should be aware of, always show the
		164	// preview.
		165	showWizard = true;
		166	} else {
		167	change = refactoring.createChange(new NullProgressMonitor());
		168	if (previewPref == JUnitPreferences.PREVIEW_IF_DESTRUCTIVE && !Helper.isDestructiveChange(change)) {
		169	showWizard = false;
		170	}
		171	}
		172	} catch (OperationCanceledException e1) {
		173	return false;
		174	} catch (CoreException e1) {
		175	ToolsUiPlugin.logError(e1);
		176	return false;
		177	}
		178	if (showWizard \|\| (change != null && !performBatchChange(change))) {
		179	UpdateCodeWizard wizard = new UpdateCodeWizard(refactoring, showWizard);
		180	wizard.setDefaultPageTitle("Code Update Preview");
		181	RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wizard);
		182	try {
		183	return op.run(this.getHyadesEditorPart().getEditorPart().getEditorSite().getShell(), "Refactoring Preview") == IDialogConstants.OK_ID;
		184	} catch (InterruptedException e) {
		185	ToolsUiPlugin.logError(e);
		186	return false;
		187	}
		188	}
		189	return true;
		190	}
136	}	191	}




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);
			}

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

					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(getImplementor().getLocation());
		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;
	}
	
}

Lines 16-21 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/wizard/JUnitTestSuiteNewWizard.java (-6 / +16 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.CorePlugin;
21	import org.eclipse.hyades.test.tools.core.common.TestCommon;	22	import org.eclipse.hyades.test.tools.core.common.TestCommon;
Lines 32-37 Link Here
32	import org.eclipse.jdt.core.JavaModelException;	33	import org.eclipse.jdt.core.JavaModelException;
33	import org.eclipse.jface.dialogs.IDialogSettings;	34	import org.eclipse.jface.dialogs.IDialogSettings;
34	import org.eclipse.jface.viewers.IStructuredSelection;	35	import org.eclipse.jface.viewers.IStructuredSelection;
		36	import org.eclipse.ltk.core.refactoring.Change;
		37	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
35		38
36	/**	39	/**
37	* Extends the HyadesNewWizard to create the JUnit Test Suite.	40	* Extends the HyadesNewWizard to create the JUnit Test Suite.
Lines 217-231 Link Here
217	}	220	}
218		221
219	protected JUnitGenerator createGenerator() {	222	protected JUnitGenerator createGenerator() {
220	return new JUnitGenerator(new AutomaticDependencyUpdater(), getSourcePage().getSuperClass());	223	return new JUnitGenerator(getGeneratedTestSuite(), new AutomaticDependencyUpdater(), getSourcePage().getSuperClass());
221	}	224	}
222		225
223	private void generateCode(ITestSuite testSuite, IProgressMonitor monitor) throws Exception {	226	private void generateCode(ITestSuite testSuite, IProgressMonitor monitor) throws Exception {
224	JUnitGenerator generator = createGenerator();	227	monitor.beginTask("", 4);
225	generator.getProjectDependencyUpdater().addRequiredPlugin("org.junit", null); //$NON-NLS-1$	228	try {
226	generator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$	229	JUnitGenerator generator = createGenerator();
227	generator.getProjectDependencyUpdater().addRequiredPlugin(CorePlugin.getID(), "java.runner.jar"); //$NON-NLS-1$	230	RefactoringStatus status = generator.checkAllConditions(new SubProgressMonitor(monitor, 1));
228	generator.generate(getGeneratedTestSuite(), monitor);	231	if (status.hasFatalError()) {
		232	throw new IllegalStateException("Refactor conditions not met"); // TODO Treat this appropriately
		233	}
		234	Change change = generator.createChange(new SubProgressMonitor(monitor, 1));
		235	change.perform(new SubProgressMonitor(monitor, 2));
		236	} finally {
		237	monitor.done();
		238	}
229	}	239	}
230		240
231	protected void setSourcePage(SourcePage page) {	241	protected void setSourcePage(SourcePage page) {

Lines 15-22 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/wizard/GenerateWizard.java (-13 / +16 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 147-153 Link Here
147	}	157	}
148		158
149	Generator generator = createGenerator();	159	Generator generator = createGenerator();
150	if(generator.getFileHandle(getTestSuite()).exists())	160	if(generator.getFileHandle().exists())
151	{	161	{
152	MessageDialog dialog = new MessageDialog(	162	MessageDialog dialog = new MessageDialog(
153	getShell(), ToolsUiPlugin.getString("W_QUESTION"), //$NON-NLS-1$	163	getShell(), ToolsUiPlugin.getString("W_QUESTION"), //$NON-NLS-1$
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	}

Lines 54-60 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/plugin/internal/junit/wizard/PluginJUnitTestSuiteNewWizard.java (-1 / +1 lines)
54	}	54	}
55		55
56	protected JUnitGenerator createGenerator() {	56	protected JUnitGenerator createGenerator() {
57	return new JUnitGenerator(new PluginProjectDependencyUpdater(), getSourcePage().getSuperClass());	57	return new JUnitGenerator(getGeneratedTestSuite(), new PluginProjectDependencyUpdater(), getSourcePage().getSuperClass());
58	}	58	}
59		59
60	protected void initSourcePage(IStructuredSelection structuredSelection, LocationPage locationPage) {	60	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.Helper;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.IProjectDependencyUpdater;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.JavaGenerator;

/**
 * @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;
	}

	public static class HttpProjectDependencyUpdater implements IProjectDependencyUpdater {

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

		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);
		}
	}

}

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
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 constants for JUnit preferences.
 * @author jcanches
 * @since 4.3
 */
public class JUnitPreferences {

	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;
	
}




/*******************************************************************************
 * 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.JUnitPreferences;
import org.eclipse.ltk.ui.refactoring.UserInputWizardPage;
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 UpdateCodeWizardPage extends UserInputWizardPage {

	protected UpdateCodeWizardPage() {
		super("JUnit Code Update Preview Options");
	}

	private Button skipPage;
	private Button alwaysPreview;
	private Button onlyDestructive;
	private Button neverPreview;

	public void createControl(Composite parent) {
		initializeDialogUnits(parent);
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(1, false);
		layout.verticalSpacing = 15;
		composite.setLayout(layout);
		
		Control group = createPreviewGroup(composite);
		group.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
		
		skipPage = new Button(composite, SWT.CHECK);
		skipPage.setText("Always skip to the preview page");
		
		setControl(composite);
		initializeContent();
	}
	
	/**
	 * @param parent
	 */
	private Control createPreviewGroup(Composite parent) {
		Group composite = new Group(parent, SWT.NONE);
		composite.setText("Show the preview page");
		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("Always");
		
		onlyDestructive = new Button(composite, SWT.RADIO);
		onlyDestructive.setText("Only when there are destructive changes");
		
		neverPreview = new Button(composite, SWT.RADIO);
		neverPreview.setText("Never");
		return composite;
	}
	
	private void initializeContent() {
		Preferences prefs = ToolsUiPlugin.getDefault().getPluginPreferences();
		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));
	}
	
	/* package */ void saveContent() {
		Preferences prefs = ToolsUiPlugin.getDefault().getPluginPreferences();
		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());
	}

}




/*******************************************************************************
 * 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.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();
	}
	
}

Lines 1-10 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/java/codegen/GenTestSuiteConstructor.java (-2 / +2 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.	2	* Copyright (c) 2005, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
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.1 2006/05/16 15:02:26 jcanches 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.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IProject;
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.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.
 * This concrete implementation handles code generation and code update for JUnit and
 * JUnit Plugin types.
 * @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());
		if (change.isRequired()) {
			return change;
		}
		return new NullChange();
	}

	protected Change createSourceUpdateChange(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(getFileHandle());
			
			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 {
			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 implements IProjectDependencyUpdater {

		private IProjectDependencyUpdater delegate;
		
		public JUnitProjectDependencyUpdater(IProjectDependencyUpdater delegate, boolean modelBehavioring) {
			this.delegate = delegate;
			delegate.addRequiredPlugin("org.junit", "junit.jar"); //$NON-NLS-1$ //$NON-NLS-2$
			if (modelBehavioring) {
				delegate.addRequiredPlugin(CorePlugin.getID(), "common.runner.jar"); //$NON-NLS-1$
				delegate.addRequiredPlugin(CorePlugin.getID(), "java.runner.jar"); //$NON-NLS-1$
					// 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);
		}

		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);
		}
		
	}
	
}

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.8 2006/05/16 15:02:26 jcanches 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/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.10 2006/05/16 15:02:26 jcanches 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.7 2006/05/16 15:02:25 jcanches Exp $	7	* $Id$
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* IBM Corporation - initial API and implementation	10	* IBM Corporation - initial API and implementation




        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 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 GENERATE_CODE;
	public static String GENERATE_FILE;
	public static String GENERATING_FILE;
	public static String GENERIC_GENERATOR;
	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 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;




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
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




 **********************************************************************/
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.PotentialChange;
import org.eclipse.hyades.test.tools.core.internal.common.codegen.changes.ProjectAdjustChange;
import org.eclipse.jdt.core.IJavaProject;
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().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();
		}
		projectDependencyUpdater.adjustProject(project, monitor);
	}
	
	/**
	 * Returns the package name that the generated class must belong to.
	 * @return A Java package name.
	 */
	protected String getPackageName() {
		String cls = getTestSuite().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() {
		String cls = getTestSuite().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());
		if (change.isRequired()) 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().getProject());
		IPackageFragmentRoot sourceFolder = jproject.getPackageFragmentRoot(getSourceContainerHandle());
		PotentialChange change = new CreatePackageFragmentChange(sourceFolder, getPackageName());
		if (change.isRequired()) 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(new SubProgressMonitor(monitor, 1));
			CompositeChange change = new CompositeChange(CommonPluginMessages.UPDATE_CODE);
			addPotentialChange(createAdjustProjectClasspathChange(new SubProgressMonitor(monitor, 1)), change);
			addPotentialChange(sourceUpdateChange, change);
			addPotentialChange(createPostCodegenerationChange(new SubProgressMonitor(monitor, 1)), change);
			change.markAsSynthetic();
			return packCompositeChange(change);
		} finally {
			monitor.done();
		}
	}

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





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);
	
}

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	}




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.hyades.models.common.facades.behavioral.ITestSuite;
import org.eclipse.hyades.models.common.util.ResourceUtil;
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()} and {@link #getSourceContainerHandle()}.</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>
 * @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;
	
	/**
	 * 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;
	}
	
	/**
	 * 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).isRequired()) 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();
			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();
		if(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();
			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();
			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() {
		IContainer sourceContainer = getSourceContainerHandle();
		return sourceContainer.getFile(new Path(testSuite.getImplementor().getResource()));
	}
	
	/**
	 * Returns the container that will receive the generated file.
	 * @return
	 */
	final protected IContainer getSourceContainerHandle() {
		IContainer container = null;
		String location = testSuite.getImplementor().getLocation();
		if (location != null) {

		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;
	
}




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;
	}

}




 **********************************************************************/
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);
		
	}
}




/**********************************************************************
 * Copyright (c) 2005, 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 - Initial API and implementation
 **********************************************************************/
package org.eclipse.hyades.test.tools.core.internal.manual.codegen;

import java.util.Iterator;

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




Bundle-ManifestVersion: 2
Bundle-Name: TPTP Test Tools Core Plug-In
Bundle-SymbolicName: org.eclipse.hyades.test.tools.core; singleton:=true
Bundle-Version: 4.2.1.qualifier
Bundle-ClassPath: tools-core.jar,
 common.runner.jar,
 manual.runner.jar,

 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





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, 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;

/**
 * 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;

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 isRequired() {
		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.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;

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;

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 isRequired() {
		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 isRequired();
	
}




/*******************************************************************************
 * 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;

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 isRequired() {
		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;

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;

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;

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 isRequired() {
		return !container.isAccessible();
	}

}

Return to bug 134254

Lines 441-446 Link Here

(-)plugin.xml (+14 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 11-22 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/editor/JUnitTestCasesForm.java (+5 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.hyades.test.tools.ui.java.internal.junit.editor;	12	package org.eclipse.hyades.test.tools.ui.java.internal.junit.editor;
13		13
		14	import org.eclipse.emf.ecore.EStructuralFeature;
		15	import org.eclipse.hyades.models.common.testprofile.Common_TestprofilePackage;
14	import org.eclipse.hyades.test.tools.core.common.TestCommon;	16	import org.eclipse.hyades.test.tools.core.common.TestCommon;
15	import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;	17	import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
16	import org.eclipse.hyades.test.tools.ui.common.internal.editor.TestCasesForm;	18	import org.eclipse.hyades.test.tools.ui.common.internal.editor.TestCasesForm;
17	import org.eclipse.hyades.test.tools.ui.common.internal.editor.action.AddTestCase;	19	import org.eclipse.hyades.test.tools.ui.common.internal.editor.action.AddTestCase;
18	import org.eclipse.hyades.test.tools.ui.java.internal.util.ContextIds;	20	import org.eclipse.hyades.test.tools.ui.java.internal.util.ContextIds;
		21	import org.eclipse.hyades.test.ui.editor.form.util.EditorForm;
19	import org.eclipse.hyades.test.ui.editor.form.util.WidgetFactory;	22	import org.eclipse.hyades.test.ui.editor.form.util.WidgetFactory;
		23	import org.eclipse.hyades.test.ui.internal.editor.form.util.EObjectTreeSection;
20	import org.eclipse.jface.action.IAction;	24	import org.eclipse.jface.action.IAction;
21	import org.eclipse.swt.widgets.Control;	25	import org.eclipse.swt.widgets.Control;
22	import org.eclipse.ui.help.WorkbenchHelp;	26	import org.eclipse.ui.help.WorkbenchHelp;
Lines 70-73 Link Here
70	break;	74	break;
71	}	75	}
72	}	76	}
		77
73	}	78	}

Added Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/JUnitPreferences.java (+32 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.ui.java.internal.junit;
14
15
16	/**
17	* Preferences constants for JUnit preferences.
18	* @author jcanches
19	* @since 4.3
20	*/
21	public class JUnitPreferences {
22
23	public final static String UPDATE_PREVIEW_MODE = "junit.previewMode"; //$NON-NLS-1$
24	public final static int PREVIEW_ALWAYS = 0;
25	public final static int PREVIEW_IF_DESTRUCTIVE = 1;
26	public final static int PREVIEW_NEVER = 2;
27	public final static int DEFAULT_UPDATE_PREVIEW_MODE = PREVIEW_ALWAYS;
28
29	public final static String SKIP_TO_PREVIEW_PAGE = "junit.skipToPreviewPage"; //$NON-NLS-1$
30	public final static boolean DEFAULT_SKIP_TO_PREVIEW_PAGE = false;
31
32	}

Lines 23-35 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/CommonPluginMessages.java (-1 / +22 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 DEFINE_SOURCE_FOLDER;
		31	public static String DELETE_FILE;
		32	public static String DELETING_FILE;
		33	public static String E_CODEGEN_PACK_DIAG;
27	public static String E_CODEGEN_CLASS_DIAG;	34	public static String E_CODEGEN_CLASS_DIAG;
28	public static String E_CODEGEN_CLOSED_PROJECT;	35	public static String E_CODEGEN_CLOSED_PROJECT;
29	public static String E_CODEGEN_NO_SRCFOLDER;	36	public static String E_CODEGEN_NO_SRCFOLDER;
30		37
31	public static String _ERROR_LAUNCH_VALIDATOR;	38	public static String _ERROR_LAUNCH_VALIDATOR;
32	public static String _WARNING_LAUNCH_VALIDATOR;	39	public static String _WARNING_LAUNCH_VALIDATOR;
		40	public static String GENERATE_CODE;
		41	public static String GENERATE_FILE;
		42	public static String GENERATING_FILE;
		43	public static String GENERIC_GENERATOR;
		44	public static String NO_FILE;
		45	public static String NO_SOURCE_FOLDER;
		46	public static String NOT_A_SOURCE_FOLDER;
		47	public static String NOT_IN_JAVA_PROJECT;
		48	public static String PROJECT_NOT_ACCESSIBLE;
		49	public static String READ_ONLY_FILE;
		50	public static String RESOURCE_NOT_ACCESSIBLE;
		51	public static String SETUP_CONTEXT;
		52	public static String UNKNOWN_LOCATION;
		53	public static String UPDATE_CODE;
33	public static String VALIDATION_NO_HOST_NAME_ERROR;	54	public static String VALIDATION_NO_HOST_NAME_ERROR;
34	public static String VALIDATION_BAD_ROOTDIR_ERROR_;	55	public static String VALIDATION_BAD_ROOTDIR_ERROR_;
35	public static String _WARNING_BUILD_PATH_PROBLEM;	56	public static String _WARNING_BUILD_PATH_PROBLEM;

Lines 22-25 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/messages.properties (-1 / +22 lines)
22	VALIDATION_NO_HOST_NAME_ERROR = No host name found	22	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}	23	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}.	24	_WARNING_BUILD_PATH_PROBLEM = Java build path errors exist in enclosing project: {0}.
25	_WARNING_COMPILATION_PROBLEM = Compilation errors exist in enclosing project: {0}.	25	_WARNING_COMPILATION_PROBLEM = Compilation errors exist in enclosing project: {0}.
		26	CREATE_PACKAGE=Create package {0}
		27	CREATE_CONTAINER=Create container {0}
		28	NO_SOURCE_FOLDER=Source folder doesn't exist
		29	NOT_A_SOURCE_FOLDER=Package fragment root is not a source folder
		30	NOT_IN_JAVA_PROJECT=Container {0} does not belong to a Java project
		31	ASSOCIATE_TEST_TO_SOURCE=Associate test {0} to source {1}
		32	NO_FILE=File does not exist
		33	READ_ONLY_FILE=File is read-only
		34	DELETING_FILE=Deleting file
		35	DELETE_FILE=Delete file {0}
		36	DEFINE_SOURCE_FOLDER=Define {0} as a source folder
		37	RESOURCE_NOT_ACCESSIBLE=Resource {0} is not accessible
		38	ADJUST_CLASSPATH=Adjust classpath for project {0}
		39	PROJECT_NOT_ACCESSIBLE=Project '{0}' is not accessible
		40	GENERATE_FILE=Generate file {0}
		41	GENERATE_CODE=Generate code
		42	UNKNOWN_LOCATION=Unknown location for file
		43	GENERATING_FILE=Generating file
		44	GENERIC_GENERATOR=Generic TPTP code generator
		45	SETUP_CONTEXT=Setup context
		46	UPDATE_CODE=Update code

Lines 18-45 Link Here

(-)src/org/eclipse/hyades/test/tools/core/internal/common/codegen/JavaProjectDependencyUpdater.java (-14 / +58 lines)
18	import java.util.ArrayList;	18	import java.util.ArrayList;
19	import java.util.Arrays;	19	import java.util.Arrays;
20	import java.util.Collection;	20	import java.util.Collection;
		21	import java.util.Collections;
21	import java.util.HashSet;	22	import java.util.HashSet;
22	import java.util.Iterator;	23	import java.util.Iterator;
23	import java.util.List;	24	import java.util.List;
24	import java.util.Set;
25		25
26	import org.eclipse.core.resources.IProject;	26	import org.eclipse.core.resources.IProject;
27	import org.eclipse.core.resources.ResourcesPlugin;	27	import org.eclipse.core.runtime.FileLocator;
28	import org.eclipse.core.runtime.ILibrary;
29	import org.eclipse.core.runtime.IPath;	28	import org.eclipse.core.runtime.IPath;
30	import org.eclipse.core.runtime.IProgressMonitor;	29	import org.eclipse.core.runtime.IProgressMonitor;
31	import org.eclipse.core.runtime.Path;	30	import org.eclipse.core.runtime.Path;
32	import org.eclipse.core.runtime.Platform;	31	import org.eclipse.core.runtime.Platform;
33	import org.eclipse.core.runtime.Plugin;	32	import org.eclipse.core.runtime.Plugin;
34	import org.eclipse.emf.common.util.URI;	33	import org.eclipse.emf.common.util.URI;
35	import org.eclipse.hyades.models.common.facades.behavioral.ITestSuite;
36	import org.eclipse.hyades.models.common.util.IDisposable;	34	import org.eclipse.hyades.models.common.util.IDisposable;
37	import org.eclipse.hyades.test.tools.core.CorePlugin;	35	import org.eclipse.hyades.test.tools.core.CorePlugin;
38	import org.eclipse.jdt.core.IClasspathEntry;	36	import org.eclipse.jdt.core.IClasspathEntry;
39	import org.eclipse.jdt.core.IJavaProject;	37	import org.eclipse.jdt.core.IJavaProject;
40	import org.eclipse.jdt.core.JavaCore;	38	import org.eclipse.jdt.core.JavaCore;
41	import org.eclipse.jdt.core.JavaModelException;	39	import org.eclipse.jdt.core.JavaModelException;
		40	import org.eclipse.osgi.util.ManifestElement;
42	import org.osgi.framework.Bundle;	41	import org.osgi.framework.Bundle;
		42	import org.osgi.framework.BundleException;
		43	import org.osgi.framework.Constants;
43		44
44	public class JavaProjectDependencyUpdater implements IProjectDependencyUpdater, IDisposable {	45	public class JavaProjectDependencyUpdater implements IProjectDependencyUpdater, IDisposable {
45		46
Lines 171-186 Link Here
171	if(pluginId == null)	172	if(pluginId == null)
172	return new String[0];	173	return new String[0];
173		174
174	Plugin plugin = Platform.getPlugin(pluginId);	175	Bundle bundle = Platform.getBundle(pluginId);
175		176
176	ILibrary[] pluginLibraries = plugin.getDescriptor().getRuntimeLibraries();	177	Plugin plugin;
177	List libraries = new ArrayList(pluginLibraries.length);	178	String requires = (String)bundle.getHeaders().get(Constants.BUNDLE_CLASSPATH);
178	for(int i = 0, maxi = pluginLibraries.length; i < maxi; i++)	179	try {
179	{	180	ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, requires);
180	String variablePluginLibrary = getVariablePluginLibrary(pluginId, pluginLibraries[i].getPath().toString());	181	List libraries = new ArrayList(elements.length);
181	libraries.add(variablePluginLibrary);	182	for(int i = 0, maxi = elements.length; i < maxi; i++) {
		183	String variablePluginLibrary = getVariablePluginLibrary(pluginId, elements[i].getValue());
		184	libraries.add(variablePluginLibrary);
		185	}
		186	return (String[])libraries.toArray(new String[libraries.size()]);
		187	} catch (BundleException e) {
		188	CorePlugin.logError(e);
		189	return new String[0];
182	}	190	}
183	return (String[])libraries.toArray(new String[libraries.size()]);
184	}	191	}
185		192
186	protected static String getVariablePluginLibrary(String pluginId, String library)	193	protected static String getVariablePluginLibrary(String pluginId, String library)
Lines 193-199 Link Here
193	return ""; //$NON-NLS-1$	200	return ""; //$NON-NLS-1$
194		201
195	try {	202	try {
196	URL url = Platform.resolve(bundle.getEntry("")); //$NON-NLS-1$	203	URL url = FileLocator.resolve(bundle.getEntry("")); //$NON-NLS-1$
197	IPath pluginPath = new Path(url.getFile());	204	IPath pluginPath = new Path(url.getFile());
198	if (url.getProtocol().equals("jar")) //jar in the plugin root //$NON-NLS-1$	205	if (url.getProtocol().equals("jar")) //jar in the plugin root //$NON-NLS-1$
199	{	206	{
Lines 208-214 Link Here
208		215
209	IPath eclipseHomePath = JavaCore.getClasspathVariable(ECLIPSE_HOME);	216	IPath eclipseHomePath = JavaCore.getClasspathVariable(ECLIPSE_HOME);
210		217
211
212	// On Windows, sometimes the case of the device for the plugin does	218	// On Windows, sometimes the case of the device for the plugin does
213	// not match the case of the device for the eclipseHomePath.	219	// not match the case of the device for the eclipseHomePath.
214	// This would never happen on *nix, because it the cases were different,	220	// This would never happen on *nix, because it the cases were different,
Lines 257-260 Link Here
257		263
258	}	264	}
259		265
		266	public Collection previewAdjustProject(IProject project) {
		267	if((requiredLibraries == null \|\| requiredLibraries.isEmpty())
		268	&& (requiredProjects == null \|\| requiredProjects.isEmpty())) return Collections.EMPTY_SET;
		269
		270	IJavaProject javaProject = JavaCore.create(project);
		271	IClasspathEntry[] resolvedClasspath;
		272	List additionalClasspathEntries = new ArrayList();
		273	try {
		274	resolvedClasspath = javaProject.getResolvedClasspath(/ignoreUnresolvedEntries/true);
		275	} catch (JavaModelException e) {
		276	CorePlugin.logError(e);
		277	return Collections.EMPTY_SET;
		278	}
		279
		280	HashSet result = new HashSet();
		281
		282	if (requiredLibraries != null) {
		283	for (Iterator it = requiredLibraries.iterator(); it.hasNext();) {
		284	IClasspathEntry entry = getLibrariesEntry((String)it.next());
		285	if (!classpathContains(resolvedClasspath, entry)) {
		286	result.add(entry.getPath().toString());
		287	}
		288	}
		289	}
		290
		291	if (requiredProjects != null) {
		292	for(Iterator it = requiredProjects.iterator(); it.hasNext();) {
		293	IProject dproject = (IProject)it.next();
		294	IClasspathEntry entry = getProjectEntry(dproject);
		295	if(!classpathContains(resolvedClasspath, entry)) {
		296	result.add(dproject.getName());
		297	}
		298	}
		299	}
		300
		301	return result;
		302	}
		303
260	}	304	}

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 2-8 Link Here

(-)META-INF/MANIFEST.MF (-5 / +6 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: TPTP Test Tools Core Plug-In	3	Bundle-Name: TPTP Test Tools Core Plug-In
4	Bundle-SymbolicName: org.eclipse.hyades.test.tools.core; singleton:=true	4	Bundle-SymbolicName: org.eclipse.hyades.test.tools.core; singleton:=true
5	Bundle-Version: 4.2.0.qualifier	5	Bundle-Version: 4.2.1.qualifier
6	Bundle-ClassPath: tools-core.jar,	6	Bundle-ClassPath: tools-core.jar,
7	common.runner.jar,	7	common.runner.jar,
8	manual.runner.jar,	8	manual.runner.jar,
Lines 65-79 Link Here
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/CompilationUnitChange.java (+124 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	* Copied from org.eclipse.jdt.internal.corext.refactoring.changes.CompilationUnitChange.
24	* @author jcanches
25	* @since 4.3
26	*/
27	public class CompilationUnitChange extends TextFileChange {
28
29	private ICompilationUnit fCUnit;
30	private boolean destructive;
31
32	/**
33	* Creates a new <code>CompilationUnitChange</code>.
34	*
35	* @param name the change's name mainly used to render the change in the UI
36	* @param cunit the compilation unit this text change works on
37	* @param destructive Whether this change contains destructive changes (i.e. applying it
38	* will delete some existing code)
39	*/
40	public CompilationUnitChange(String name, ICompilationUnit cunit, boolean destructive) {
41	super(name, getFile(cunit));
42	Assert.isNotNull(cunit);
43	fCUnit= cunit;
44	setTextType("java"); //$NON-NLS-1$
45	this.destructive = destructive;
46	}
47
48	private static IFile getFile(ICompilationUnit cunit) {
49	return (IFile) cunit.getResource();
50	}
51
52	/* non java-doc
53	* Method declared in IChange.
54	*/
55	public Object getModifiedElement(){
56	return fCUnit;
57	}
58
59	/**
60	* Returns the compilation unit this change works on.
61	*
62	* @return the compilation unit this change works on
63	*/
64	public ICompilationUnit getCompilationUnit() {
65	return fCUnit;
66	}
67
68	/**
69	* {@inheritDoc}
70	*/
71	protected IDocument acquireDocument(IProgressMonitor pm) throws CoreException {
72	pm.beginTask("", 2); //$NON-NLS-1$
73	fCUnit.becomeWorkingCopy(null, new SubProgressMonitor(pm, 1));
74	return super.acquireDocument(new SubProgressMonitor(pm, 1));
75	}
76
77	/**
78	* {@inheritDoc}
79	*/
80	protected void releaseDocument(IDocument document, IProgressMonitor pm) throws CoreException {
81	super.releaseDocument(document, pm);
82	try {
83	fCUnit.discardWorkingCopy();
84	} finally {
85	if (!isDocumentAcquired()) {
86	if (fCUnit.isWorkingCopy())
87	fCUnit.reconcile(
88	ICompilationUnit.NO_AST,
89	false /* don't force problem detection */,
90	null /* use primary owner */,
91	null /* no progress monitor */);
92
93	else
94	fCUnit.makeConsistent(pm);
95	}
96	}
97	}
98
99	// /**
100	// * {@inheritDoc}
101	// */
102	// protected Change createUndoChange(UndoEdit edit, ContentStamp stampToRestore) {
103	// try {
104	// return new UndoCompilationUnitChange(getName(), fCUnit, edit, stampToRestore, getSaveMode());
105	// } catch (CoreException e) {
106	// JavaPlugin.log(e);
107	// return null;
108	// }
109	// }
110
111	/**
112	* {@inheritDoc}
113	*/
114	public Object getAdapter(Class adapter) {
115	if (ICompilationUnit.class.equals(adapter))
116	return fCUnit;
117	return super.getAdapter(adapter);
118	}
119
120	public boolean isDestructive() {
121	return destructive;
122	}
123	}
124