private static void makeJavaProject() throws CoreException {
testProject = JavaProjectHelper.createJavaProject(PROJECT_NAME, BIN_FOLDER_NAME);
JavaProjectHelper.addRTJar17(testProject);
JavaProjectHelper.addSourceContainer(testProject, SRC_FOLDER_NAME);
testProject.setOption("org.eclipse.jdt.core.formatter.tabulation.char", JavaCore.SPACE);
testIProject = testProject.getProject();
}
public void testRemoveFromBuildpathBug153299Src() throws Exception {
fJavaProject = createProject(null);
// Use the old behavior in order to test the fallback code. Set to ERROR since 3.8.
fJavaProject.setOption(
JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE, JavaCore.IGNORE);
IPackageFragmentRoot p01 =
JavaProjectHelper.addSourceContainer(fJavaProject, null, new IPath[] {new Path("src1/")});
JavaProjectHelper.addSourceContainer(fJavaProject, "src1");
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
BuildpathDelta delta =
ClasspathModifier.removeFromBuildpath(
new CPListElement[] {
CPListElement.createFromExisting(p01.getRawClasspathEntry(), fJavaProject)
},
cpProject);
assertDeltaResources(delta, new IPath[0], new IPath[] {}, new IPath[0], new IPath[0]);
assertDeltaDefaultOutputFolder(
delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME));
assertDeltaRemovedEntries(delta, new IPath[] {p01.getPath()});
assertDeltaAddedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 2);
}
public void testRemoveFromBuildpath01() throws Exception {
fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME);
IPackageFragmentRoot src1 = JavaProjectHelper.addSourceContainer(fJavaProject, "src1");
IPackageFragmentRoot src2 = JavaProjectHelper.addSourceContainer(fJavaProject, "src2");
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
CPListElement[] toRemove = new CPListElement[2];
toRemove[0] = CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject);
toRemove[1] = CPListElement.createFromExisting(src2.getRawClasspathEntry(), fJavaProject);
BuildpathDelta delta = ClasspathModifier.removeFromBuildpath(toRemove, cpProject);
assertDeltaResources(
delta,
new IPath[0],
new IPath[] {src1.getPath(), src2.getPath()},
new IPath[0],
new IPath[0]);
assertDeltaDefaultOutputFolder(
delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME));
assertDeltaRemovedEntries(delta, new IPath[] {src1.getPath(), src2.getPath()});
assertDeltaAddedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 1);
}
public void testCuGetClass2() throws Exception {
// Test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=211037
// In 1.6, Object#getClass() declares return type Class<?>, but in 1.5, it's Class<? extends
// Object>.
performCuOK();
// Test the same with 1.5:
IJavaProject project = RefactoringTestSetup.getProject();
ArrayList classpath = new ArrayList(Arrays.asList(project.getRawClasspath()));
IClasspathEntry jreEntry = RefactoringTestSetup.getJRELibrary().getRawClasspathEntry();
classpath.remove(jreEntry);
IClasspathEntry[] noRTJarCPEs =
(IClasspathEntry[]) classpath.toArray(new IClasspathEntry[classpath.size()]);
project.setRawClasspath(noRTJarCPEs, new NullProgressMonitor());
JavaProjectHelper.addRTJar15(project);
try {
performCuOK();
} finally {
project.setRawClasspath(noRTJarCPEs, new NullProgressMonitor());
JavaProjectHelper.addRTJar16(project);
}
}
public void testJUnitWithCloneNotRaw() throws Exception {
fAssumeCloneReturnsSameType = true;
fLeaveUnconstrainedRaw = false;
IJavaProject javaProject = JavaProjectHelper.createJavaProject("InferTypeArguments", "bin");
try {
IPackageFragmentRoot jdk = JavaProjectHelper.addRTJar(javaProject);
Assert.assertNotNull(jdk);
File junitSrcArchive =
JavaTestPlugin.getDefault().getFileInPlugin(JavaProjectHelper.JUNIT_SRC_381);
Assert.assertTrue(junitSrcArchive != null && junitSrcArchive.exists());
IPackageFragmentRoot src =
JavaProjectHelper.addSourceContainerWithImport(
javaProject, "src", junitSrcArchive, JavaProjectHelper.JUNIT_SRC_ENCODING);
boolean performed =
perform(new IJavaElement[] {javaProject}, RefactoringStatus.OK, RefactoringStatus.OK);
assertTrue(performed);
compareWithZipFile(src, "junit381-noUI-clone-not-raw-src.zip");
} finally {
if (javaProject != null && javaProject.exists()) JavaProjectHelper.delete(javaProject);
}
}
public void testAddSafeVarargsToDeclaration5() throws Exception {
JavaProjectHelper.set15CompilerOptions(fJProject1);
try {
IPackageFragment pack1 = fSourceFolder.createPackageFragment("p", false, null);
StringBuffer buf = new StringBuffer();
buf.append("package p;\n");
buf.append("import java.util.List;\n");
buf.append("public class E {\n");
buf.append(" void foo() {\n");
buf.append(" Y.asList(Y.asList(\"Hello\", \" World\"));\n");
buf.append(" }\n");
buf.append("}\n");
buf.append("class Y {\n");
buf.append(" public static <T> List<T> asList(T... a) {\n");
buf.append(" return null;\n");
buf.append(" }\n");
buf.append("}\n");
ICompilationUnit cu = pack1.createCompilationUnit("E.java", buf.toString(), false, null);
CompilationUnit astRoot = getASTRoot(cu);
ArrayList<IJavaCompletionProposal> proposals = collectCorrections(cu, astRoot);
assertNumberOfProposals(proposals, 2);
assertProposalDoesNotExist(proposals, "Add @SafeVarargs to 'asList(..)'");
} finally {
JavaProjectHelper.set17CompilerOptions(fJProject1);
}
}
public void setUp() throws Exception {
fJavaProject1 = JavaProjectHelper.createJavaProject("TestProject1", "bin");
fJavaProject2 = JavaProjectHelper.createJavaProject("TestProject2", "bin");
fType1 = null;
fType2 = null;
fPack1 = null;
fPack2 = null;
}
private static IJavaProject createProject(String defaultOutputFolder) throws CoreException {
IJavaProject result = JavaProjectHelper.createJavaProject(PROJECT_NAME, defaultOutputFolder);
IPath[] rtJarPath = JavaProjectHelper.findRtJar(JavaProjectHelper.RT_STUBS_15);
result.setRawClasspath(
new IClasspathEntry[] {
JavaCore.newLibraryEntry(rtJarPath[0], rtJarPath[1], rtJarPath[2], true)
},
null);
return result;
}
public void testEditOutputFolder04RemoveProjectAndExcludeOutput() throws Exception {
fJavaProject = createProject(null);
// Use the old behavior in order to test the fallback code. Set to ERROR since 3.8.
fJavaProject.setOption(
JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE, JavaCore.IGNORE);
JavaProjectHelper.addSourceContainer(
fJavaProject, null, new IPath[] {new Path("src1/"), new Path("src2/")});
IPackageFragmentRoot src1 = JavaProjectHelper.addSourceContainer(fJavaProject, "src1");
IPackageFragmentRoot src2 = JavaProjectHelper.addSourceContainer(fJavaProject, "src2");
IPath projectPath = fJavaProject.getProject().getFullPath();
IPath outputPath = projectPath.append("src2").append(DEFAULT_OUTPUT_FOLDER_NAME);
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
CPListElement element =
cpProject.getCPElement(
CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject));
IStatus status =
ClasspathModifier.checkSetOutputLocationPrecondition(element, outputPath, false, cpProject);
assertTrue(status.getMessage(), status.getSeverity() == IStatus.INFO);
BuildpathDelta delta =
ClasspathModifier.setOutputLocation(element, outputPath, false, cpProject);
assertDeltaResources(delta, new IPath[] {outputPath}, new IPath[0], new IPath[0], new IPath[0]);
assertDeltaDefaultOutputFolder(
delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME));
assertDeltaRemovedEntries(delta, new IPath[] {fJavaProject.getPath()});
assertDeltaAddedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
assertTrue(
"Default output folder was not set to bin",
fJavaProject
.getOutputLocation()
.equals(fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME)));
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 3);
IClasspathEntry entry = classpathEntries[1];
assertTrue(src1.getRawClasspathEntry() == entry);
IPath location = entry.getOutputLocation();
assertTrue(
"Output path is " + location + " expected was " + outputPath, outputPath.equals(location));
entry = classpathEntries[2];
assertTrue(src2.getRawClasspathEntry() == entry);
IPath[] exclusionPatterns = entry.getExclusionPatterns();
assertTrue(exclusionPatterns.length == 1);
assertTrue(exclusionPatterns[0].toString().equals("bin/"));
}
/**
* Creates two packages (pack1 and pack2) in different projects. Sets the instance fields fPack1
* and fPack2.
*/
public void createPackages() throws CoreException, JavaModelException {
JavaProjectHelper.addRTJar(fJavaProject1);
IPackageFragmentRoot root1 = JavaProjectHelper.addSourceContainer(fJavaProject1, "src");
fPack1 = root1.createPackageFragment("pack1", true, null);
JavaProjectHelper.addRTJar(fJavaProject2);
JavaProjectHelper.addRequiredProject(fJavaProject2, fJavaProject1);
IPackageFragmentRoot root2 = JavaProjectHelper.addSourceContainer(fJavaProject2, "src");
fPack2 = root2.createPackageFragment("pack2", true, null);
}
/**
* Removes contents of {@link #getPackageP()}, of {@link #getRoot()} (except for p) and of the
* Java project (except for src and the JRE library).
*
* @throws Exception in case of errors
*/
protected void tearDown() throws Exception {
refreshFromLocal();
performDummySearch();
final boolean pExists = getPackageP().exists();
if (pExists) {
tryDeletingAllJavaChildren(getPackageP());
tryDeletingAllNonJavaChildResources(getPackageP());
}
if (getRoot().exists()) {
IJavaElement[] packages = getRoot().getChildren();
for (int i = 0; i < packages.length; i++) {
IPackageFragment pack = (IPackageFragment) packages[i];
if (!pack.equals(getPackageP()) && pack.exists() && !pack.isReadOnly())
if (pack.isDefaultPackage()) pack.delete(true, null);
else
JavaProjectHelper.delete(pack.getResource()); // also delete packages with subpackages
}
// Restore package 'p'
if (!pExists) getRoot().createPackageFragment("p", true, null);
tryDeletingAllNonJavaChildResources(getRoot());
}
restoreTestProject();
}
public void testRemoveFromBuildpathBug153299Lib() throws Exception {
fJavaProject = createProject(null);
IPackageFragmentRoot p01 =
JavaProjectHelper.addSourceContainer(fJavaProject, null, new IPath[] {new Path("src1/")});
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
IPath[] jarPaths = new IPath[] {JavaProjectHelper.MYLIB.makeAbsolute()};
ClasspathModifier.addExternalJars(jarPaths, cpProject);
ClasspathModifier.commitClassPath(cpProject, null);
cpProject = CPJavaProject.createFromExisting(fJavaProject);
BuildpathDelta delta =
ClasspathModifier.removeFromBuildpath(
new CPListElement[] {
CPListElement.createFromExisting(p01.getRawClasspathEntry(), fJavaProject)
},
cpProject);
assertDeltaResources(delta, new IPath[0], new IPath[] {}, new IPath[0], new IPath[0]);
assertDeltaDefaultOutputFolder(delta, fJavaProject.getPath());
assertDeltaRemovedEntries(delta, new IPath[] {p01.getPath()});
assertDeltaAddedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 2);
}
public void testEditOutputFolder05CannotOutputToSource() throws Exception {
fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME);
IPackageFragmentRoot src1 = JavaProjectHelper.addSourceContainer(fJavaProject, "src1");
JavaProjectHelper.addSourceContainer(fJavaProject, "src2");
IPath projectPath = fJavaProject.getProject().getFullPath();
IPath outputPath = projectPath.append("src2");
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
CPListElement element =
cpProject.getCPElement(
CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject));
IStatus status =
ClasspathModifier.checkSetOutputLocationPrecondition(element, outputPath, false, cpProject);
assertTrue(status.getMessage(), status.getSeverity() == IStatus.ERROR);
}
public void testEditOutputFolder01SetOutputFolderForSourceFolder() throws Exception {
fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME);
IPackageFragmentRoot src = JavaProjectHelper.addSourceContainer(fJavaProject, "src");
IPath projectPath = fJavaProject.getProject().getFullPath();
IPath outputPath = projectPath.append("srcbin");
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
CPListElement element =
cpProject.getCPElement(
CPListElement.createFromExisting(src.getRawClasspathEntry(), fJavaProject));
IStatus status =
ClasspathModifier.checkSetOutputLocationPrecondition(element, outputPath, false, cpProject);
assertTrue(status.getMessage(), status.getSeverity() != IStatus.ERROR);
BuildpathDelta delta =
ClasspathModifier.setOutputLocation(element, outputPath, false, cpProject);
assertDeltaResources(delta, new IPath[] {outputPath}, new IPath[0], new IPath[0], new IPath[0]);
assertDeltaDefaultOutputFolder(delta, fJavaProject.getOutputLocation());
assertDeltaAddedEntries(delta, new IPath[0]);
assertDeltaRemovedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 2);
IClasspathEntry entry = classpathEntries[1];
assertTrue(src.getRawClasspathEntry() == entry);
IPath location = entry.getOutputLocation();
assertTrue(
"Output path is " + location + " expected was " + outputPath, outputPath.equals(location));
}
private void restoreTestProject() throws Exception {
IJavaProject javaProject = getRoot().getJavaProject();
if (javaProject.exists()) {
IClasspathEntry srcEntry = getRoot().getRawClasspathEntry();
IClasspathEntry jreEntry = RefactoringTestSetup.getJRELibrary().getRawClasspathEntry();
IClasspathEntry[] cpes = javaProject.getRawClasspath();
ArrayList newCPEs = new ArrayList();
boolean cpChanged = false;
for (int i = 0; i < cpes.length; i++) {
IClasspathEntry cpe = cpes[i];
if (cpe.equals(srcEntry) || cpe.equals(jreEntry)) {
newCPEs.add(cpe);
} else {
cpChanged = true;
}
}
if (cpChanged) {
IClasspathEntry[] newCPEsArray =
(IClasspathEntry[]) newCPEs.toArray(new IClasspathEntry[newCPEs.size()]);
javaProject.setRawClasspath(newCPEsArray, null);
}
Object[] nonJavaResources = javaProject.getNonJavaResources();
for (int i = 0; i < nonJavaResources.length; i++) {
Object kid = nonJavaResources[i];
if (kid instanceof IResource) {
IResource resource = (IResource) kid;
if (!PROJECT_RESOURCE_CHILDREN.contains(resource.getName())) {
JavaProjectHelper.delete(resource);
}
}
}
}
}
/**
* Creates a Java project with JUnit source and rt.jar from {@link #addVariableRTJar(IJavaProject,
* String, String, String)}.
*
* @param projectName the project name
* @param srcContainerName the source container name
* @param outputFolderName the output folder name
* @return the IJavaProject
* @throws CoreException
* @throws IOException
* @throws InvocationTargetException
* @since 3.1
*/
public static IJavaProject createJavaProjectWithJUnitSource(
String projectName, String srcContainerName, String outputFolderName)
throws CoreException, IOException, InvocationTargetException {
IJavaProject project = createJavaProject(projectName, outputFolderName);
IPackageFragmentRoot jdk =
JavaProjectHelper.addVariableRTJar(project, "JRE_LIB_TEST", null, null); // $NON-NLS-1$
Assert.assertNotNull(jdk);
File junitSrcArchive = JavaTestPlugin.getDefault().getFileInPlugin(JUNIT_SRC_381);
Assert.assertTrue(junitSrcArchive != null && junitSrcArchive.exists());
JavaProjectHelper.addSourceContainerWithImport(
project, srcContainerName, junitSrcArchive, JUNIT_SRC_ENCODING);
return project;
}
private static void tryDeletingAllJavaChildren(IPackageFragment pack) throws CoreException {
IJavaElement[] kids = pack.getChildren();
for (int i = 0; i < kids.length; i++) {
if (kids[i] instanceof ISourceManipulation) {
if (kids[i].exists() && !kids[i].isReadOnly()) JavaProjectHelper.delete(kids[i]);
}
}
}
public static IPackageFragmentRoot addRTJar13(IJavaProject jproject) throws CoreException {
IPath[] rtJarPath = findRtJar(RT_STUBS_13);
Map options = jproject.getOptions(false);
JavaProjectHelper.set13CompilerOptions(options);
jproject.setOptions(options);
return addLibrary(jproject, rtJarPath[0], rtJarPath[1], rtJarPath[2]);
}
private static void tryDeletingAllNonJavaChildResources(IPackageFragmentRoot root)
throws CoreException {
Object[] nonJavaKids = root.getNonJavaResources();
for (int i = 0; i < nonJavaKids.length; i++) {
if (nonJavaKids[i] instanceof IResource) {
IResource resource = (IResource) nonJavaKids[i];
JavaProjectHelper.delete(resource);
}
}
}
protected void launchTests(String prefixForErrorMessage, int howManyNumbersInErrorString)
throws CoreException, JavaModelException {
// have to set up an 1.3 project to avoid requiring a 5.0 VM
JavaProjectHelper.addRTJar13(fProject);
JavaProjectHelper.addVariableEntry(fProject, new Path("JUNIT_HOME/junit.jar"), null, null);
IPackageFragmentRoot root = JavaProjectHelper.addSourceContainer(fProject, "src");
IPackageFragment pack = root.createPackageFragment("pack", true, null);
ICompilationUnit cu1 = pack.getCompilationUnit("LongTraceLines.java");
String initialString = prefixForErrorMessage + "Numbers:";
String initializeString = "String errorString = \"" + initialString + "\";";
String contents =
"public class LongTraceLines extends TestCase {\n"
+ " public void testLongTraceLine() throws Exception {\n"
+ (" " + initializeString + "\n")
+ (" for (int i = 0; i < " + howManyNumbersInErrorString + "; i++) {\n")
+ " errorString += \" \" + i;\n"
+ " }\n"
+ " throw new RuntimeException(errorString);\n"
+ " }\n"
+ "}";
IType type = cu1.createType(contents, null, true, null);
cu1.createImport("junit.framework.TestCase", null, Flags.AccDefault, null);
cu1.createImport("java.util.Arrays", null, Flags.AccDefault, null);
ILaunchManager lm = DebugPlugin.getDefault().getLaunchManager();
lm.addLaunchListener(this);
LaunchConfigurationManager manager = DebugUIPlugin.getDefault().getLaunchConfigurationManager();
List launchShortcuts = manager.getLaunchShortcuts();
LaunchShortcutExtension ext = null;
for (Iterator iter = launchShortcuts.iterator(); iter.hasNext(); ) {
ext = (LaunchShortcutExtension) iter.next();
if (ext.getLabel().equals("JUnit Test")) break;
}
ext.launch(new StructuredSelection(type), ILaunchManager.RUN_MODE);
}
@Override
protected void setUp() throws Exception {
Hashtable<String, String> options = TestOptions.getDefaultOptions();
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
JavaCore.setOptions(options);
IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
store.setValue(PreferenceConstants.CODEGEN_ADD_COMMENTS, false);
fJProject1 = ProjectTestSetup.getProject();
fSourceFolder = JavaProjectHelper.addSourceContainer(fJProject1, "src");
}
public void testEditOutputFolderBug154044() throws Exception {
fJavaProject = createProject(DEFAULT_OUTPUT_FOLDER_NAME);
IPackageFragmentRoot src1 = JavaProjectHelper.addSourceContainer(fJavaProject, "src1");
IPath projectPath = fJavaProject.getProject().getFullPath();
IPath oldOutputPath =
projectPath.append("src1").append("sub").append(DEFAULT_OUTPUT_FOLDER_NAME);
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
CPListElement element =
cpProject.getCPElement(
CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject));
ClasspathModifier.setOutputLocation(element, oldOutputPath, false, cpProject);
ClasspathModifier.commitClassPath(cpProject, null);
IPath outputPath = projectPath.append("src1").append("sub").append("newBin");
cpProject = CPJavaProject.createFromExisting(fJavaProject);
element =
cpProject.getCPElement(
CPListElement.createFromExisting(src1.getRawClasspathEntry(), fJavaProject));
IStatus status =
ClasspathModifier.checkSetOutputLocationPrecondition(element, outputPath, false, cpProject);
assertTrue(status.getMessage(), status.isOK());
BuildpathDelta delta =
ClasspathModifier.setOutputLocation(element, outputPath, false, cpProject);
assertDeltaResources(
delta, new IPath[] {outputPath}, new IPath[] {oldOutputPath}, new IPath[0], new IPath[0]);
assertDeltaDefaultOutputFolder(
delta, fJavaProject.getPath().append(DEFAULT_OUTPUT_FOLDER_NAME));
assertDeltaRemovedEntries(delta, new IPath[0]);
assertDeltaAddedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 2);
IClasspathEntry entry = classpathEntries[1];
assertTrue(src1.getRawClasspathEntry() == entry);
IPath location = entry.getOutputLocation();
assertTrue(
"Output path is " + location + " expected was " + outputPath, outputPath.equals(location));
IPath[] exclusionPatterns = entry.getExclusionPatterns();
assertTrue(exclusionPatterns.length == 1);
assertTrue(
exclusionPatterns[0].toString(), exclusionPatterns[0].toString().equals("sub/newBin/"));
}
/**
* Removes all files in the project and sets the given classpath
*
* @param jproject The project to clear
* @param entries The default class path to set
* @throws Exception Clearing the project failed
*/
public static void clear(final IJavaProject jproject, final IClasspathEntry[] entries)
throws Exception {
performDummySearch();
IWorkspaceRunnable runnable =
new IWorkspaceRunnable() {
public void run(IProgressMonitor monitor) throws CoreException {
jproject.setRawClasspath(entries, null);
IResource[] resources = jproject.getProject().members();
for (int i = 0; i < resources.length; i++) {
if (!resources[i].getName().startsWith(".")) {
delete(resources[i]);
}
}
}
};
ResourcesPlugin.getWorkspace().run(runnable, null);
JavaProjectHelper.emptyDisplayLoop();
}
@Override
protected void setUp() throws Exception {
Hashtable<String, String> options = TestOptions.getDefaultOptions();
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
options.put(
DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_LOCAL_VARIABLE,
JavaCore.DO_NOT_INSERT);
JavaCore.setOptions(options);
IPreferenceStore store = JavaPlugin.getDefault().getPreferenceStore();
store.setValue(PreferenceConstants.CODEGEN_ADD_COMMENTS, false);
fJProject1 = Java18ProjectTestSetup.getProject();
StubUtility.setCodeTemplate(CodeTemplateContextType.METHODSTUB_ID, "", null);
StubUtility.setCodeTemplate(CodeTemplateContextType.CONSTRUCTORSTUB_ID, "", null);
fSourceFolder = JavaProjectHelper.addSourceContainer(fJProject1, "src");
}
public void testRemoveFromBuildpath01RemoveProject() throws Exception {
fJavaProject = createProject(null);
IPackageFragmentRoot p01 = JavaProjectHelper.addSourceContainer(fJavaProject, null);
CPJavaProject cpProject = CPJavaProject.createFromExisting(fJavaProject);
BuildpathDelta delta =
ClasspathModifier.removeFromBuildpath(
new CPListElement[] {
CPListElement.createFromExisting(p01.getRawClasspathEntry(), fJavaProject)
},
cpProject);
assertDeltaResources(delta, new IPath[0], new IPath[] {}, new IPath[0], new IPath[0]);
assertDeltaDefaultOutputFolder(delta, fJavaProject.getPath());
assertDeltaRemovedEntries(delta, new IPath[] {p01.getPath()});
assertDeltaAddedEntries(delta, new IPath[0]);
ClasspathModifier.commitClassPath(cpProject, null);
IClasspathEntry[] classpathEntries = fJavaProject.getRawClasspath();
assertNumberOfEntries(classpathEntries, 1);
}
protected void tearDown() throws Exception {
JavaProjectHelper.delete(fProject);
}
/**
* Sets the compiler options to 1.4 for the given project.
*
* @param project the java project
*/
public static void set14CompilerOptions(IJavaProject project) {
Map options = project.getOptions(false);
JavaProjectHelper.set14CompilerOptions(options);
project.setOptions(options);
}
protected void tearDown() throws Exception {
if (fJavaProject != null) {
JavaProjectHelper.delete(fJavaProject);
fJavaProject = null;
}
}
/**
* Invokes the introduce indirection ref. Some pointers:
*
* @param topLevelName This is an array of fully qualified top level(!) type names with exactly
* one package prefix (e.g. "p.Foo"). Simple names must correspond to .java files. The first
* cu will be used for the invocation of the refactoring (see positioning)
* @param newName name of indirection method
* @param qTypeName qualified type name of the type for the indirection method. Should be one of
* the cus in topLevelName.
* @param startLine starting line of selection in topLevelName[0]
* @param startColumn starting column of selection in topLevelName[0]
* @param endLine ending line of selection in topLevelName[0]
* @param endColumn ending column of selection in topLevelName[0]
* @param updateReferences true if references should be updated
* @param shouldWarn if true, warnings will be expected in the result
* @param shouldError if true, errors will be expected in the result
* @param shouldFail if true, fatal errors will be expected in the result
* @throws Exception
* @throws JavaModelException
* @throws CoreException
* @throws IOException
*/
private void helper(
String[] topLevelName,
String newName,
String qTypeName,
int startLine,
int startColumn,
int endLine,
int endColumn,
boolean updateReferences,
boolean shouldWarn,
boolean shouldError,
boolean shouldFail)
throws Exception, JavaModelException, CoreException, IOException {
ICompilationUnit[] cu = new ICompilationUnit[topLevelName.length];
for (int i = 0; i < topLevelName.length; i++) {
String packName = topLevelName[i].substring(0, topLevelName[i].indexOf('.'));
String className = topLevelName[i].substring(topLevelName[i].indexOf('.') + 1);
IPackageFragment cPackage = getRoot().createPackageFragment(packName, true, null);
cu[i] = createCUfromTestFile(cPackage, className);
}
ISourceRange selection =
TextRangeUtil.getSelection(cu[0], startLine, startColumn, endLine, endColumn);
try {
IntroduceIndirectionRefactoring ref =
new IntroduceIndirectionRefactoring(cu[0], selection.getOffset(), selection.getLength());
ref.setEnableUpdateReferences(updateReferences);
if (qTypeName != null) ref.setIntermediaryClassName(qTypeName);
if (newName != null) ref.setIntermediaryMethodName(newName);
boolean failed = false;
RefactoringStatus status = performRefactoringWithStatus(ref);
if (status.hasFatalError()) {
assertTrue(
"Failed but shouldn't: " + status.getMessageMatchingSeverity(RefactoringStatus.FATAL),
shouldFail);
failed = true;
} else assertFalse("Didn't fail although expected", shouldFail);
if (!failed) {
if (status.hasError())
assertTrue(
"Had errors but shouldn't: "
+ status.getMessageMatchingSeverity(RefactoringStatus.ERROR),
shouldError);
else assertFalse("No error although expected", shouldError);
if (status.hasWarning())
assertTrue(
"Had warnings but shouldn't: "
+ status.getMessageMatchingSeverity(RefactoringStatus.WARNING),
shouldWarn);
else assertFalse("No warning although expected", shouldWarn);
for (int i = 0; i < topLevelName.length; i++) {
String className = topLevelName[i].substring(topLevelName[i].indexOf('.') + 1);
assertEqualLines(
"invalid output.",
getFileContents(getOutputTestFileName(className)),
cu[i].getSource());
}
}
} finally {
for (int i = 0; i < topLevelName.length; i++) JavaProjectHelper.delete(cu[i]);
}
}
protected void performDummySearch() throws Exception {
JavaProjectHelper.performDummySearch(getPackageP());
}