/*******************************************************************************
* Copyright (c) 2000, 2013 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.che.plugin.java.server.jdt.refactoring;
import junit.framework.TestCase;
import org.eclipse.che.plugin.java.server.jdt.testplugin.JavaProjectHelper;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourceAttributes;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.refactoring.IJavaElementMapper;
import org.eclipse.jdt.core.refactoring.IJavaRefactorings;
import org.eclipse.jdt.core.refactoring.descriptors.RenameJavaElementDescriptor;
import org.eclipse.jdt.internal.core.refactoring.descriptors.RefactoringSignatureDescriptorFactory;
import org.eclipse.jdt.internal.corext.refactoring.rename.RenamePackageProcessor;
import org.eclipse.jdt.internal.corext.refactoring.util.JavaElementUtil;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.ltk.core.refactoring.IResourceMapper;
import org.eclipse.ltk.core.refactoring.IUndoManager;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.participants.MoveArguments;
import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring;
import org.eclipse.ltk.core.refactoring.participants.RefactoringProcessor;
import org.eclipse.ltk.core.refactoring.participants.RenameArguments;
import org.eclipse.ltk.core.refactoring.participants.RenameRefactoring;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import static junit.framework.TestCase.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
public class RenamePackageTest extends RefactoringTest {
private static final boolean BUG_PACKAGE_CANT_BE_RENAMED_TO_A_PACKAGE_THAT_ALREADY_EXISTS = true;
private static final boolean BUG_6054 = false;
private static final boolean BUG_54962_71267 = false;
// private static final Class clazz= RenamePackageTests.class;
private static final String REFACTORING_PATH = "RenamePackage/";
private boolean fUpdateReferences;
private boolean fUpdateTextualMatches;
private String fQualifiedNamesFilePatterns;
private boolean fRenameSubpackages;
// public RenamePackageTest(String name) {
// super(name);
// }
//
// public static Test suite() {
// return new Java15Setup(new TestSuite(clazz));
// }
//
// public static Test setUpTest(Test someTest) {
// return new Java15Setup(someTest);
// }
// public void run(TestResult result) {
// System.out.println("--- " + getName() + " - RenamePackageTests ---");
// super.run(result);
// }
private RefactoringTestSetup setup = new RefactoringTestSetup();
@BeforeClass
public static void prepareClass() {
ParticipantTesting.init();
}
@Before
public void setUp() throws Exception {
setup.setUp();
super.setUp();
fUpdateReferences = true;
fUpdateTextualMatches = false;
fQualifiedNamesFilePatterns = null;
fRenameSubpackages = false;
// fIsPreDeltaTest= true;
}
@Override
@After
public void tearDown() throws Exception {
// super.tearDown();
setup.tearDown();
}
protected String getRefactoringPath() {
return REFACTORING_PATH;
}
// -------------
private RenameJavaElementDescriptor createRefactoringDescriptor(IPackageFragment pack, String newName) {
RenameJavaElementDescriptor descriptor =
RefactoringSignatureDescriptorFactory.createRenameJavaElementDescriptor(IJavaRefactorings.RENAME_PACKAGE);
descriptor.setJavaElement(pack);
descriptor.setNewName(newName);
descriptor.setUpdateReferences(true);
return descriptor;
}
/* non java-doc
* the 0th one is the one to rename
*/
private void helper1(String packageNames[], String[][] packageFiles, String newPackageName) throws Exception {
IPackageFragment[] packages = new IPackageFragment[packageNames.length];
for (int i = 0; i < packageFiles.length; i++) {
packages[i] = getRoot().createPackageFragment(packageNames[i], true, null);
for (int j = 0; j < packageFiles[i].length; j++) {
createCUfromTestFile(packages[i], packageFiles[i][j], packageNames[i].replace('.', '/') + "/");
//DebugUtils.dump(cu.getElementName() + "\n" + cu.getSource());
}
}
IPackageFragment thisPackage = packages[0];
RefactoringStatus result = performRefactoring(createRefactoringDescriptor(thisPackage, newPackageName));
assertNotNull("precondition was supposed to fail", result);
// if (fIsVerbose)
// DebugUtils.dump("" + result);
}
private void helper1() throws Exception {
helper1(new String[]{"r"}, new String[][]{{"A"}}, "p1");
}
private RenamePackageProcessor helper2(String[] packageNames, String[][] packageFileNames, String newPackageName) throws Exception {
ParticipantTesting.reset();
IPackageFragment[] packages = new IPackageFragment[packageNames.length];
ICompilationUnit[][] cus = new ICompilationUnit[packageFileNames.length][packageFileNames[0].length];
for (int i = 0; i < packageNames.length; i++) {
packages[i] = getRoot().createPackageFragment(packageNames[i], true, null);
for (int j = 0; j < packageFileNames[i].length; j++) {
cus[i][j] = createCUfromTestFile(packages[i], packageFileNames[i][j], packageNames[i].replace('.', '/') + "/");
}
}
IPackageFragment thisPackage = packages[0];
boolean hasSubpackages = thisPackage.hasSubpackages();
IPath path = thisPackage.getParent().getPath();
path = path.append(newPackageName.replace('.', '/'));
IFolder target = ResourcesPlugin.getWorkspace().getRoot().getFolder(path);
boolean targetExists = target.exists();
boolean isRename =
!targetExists && !thisPackage.hasSubpackages() && thisPackage.getResource().getParent().equals(target.getParent());
String[] createHandles = null;
String[] moveHandles = null;
String[] deleteHandles = null;
boolean doDelete = true;
String[] renameHandles = null;
if (isRename) {
renameHandles = ParticipantTesting.createHandles(thisPackage, thisPackage.getResource());
} else {
renameHandles = ParticipantTesting.createHandles(thisPackage);
IContainer loop = target;
List handles = new ArrayList();
while (loop != null && !loop.exists()) {
handles.add(ParticipantTesting.createHandles(loop)[0]);
loop = loop.getParent();
}
createHandles = (String[])handles.toArray(new String[handles.size()]);
IFolder source = (IFolder)thisPackage.getResource();
deleteHandles = ParticipantTesting.createHandles(source);
IResource members[] = source.members();
List movedObjects = new ArrayList();
for (int i = 0; i < members.length; i++) {
if (members[i] instanceof IFolder) {
doDelete = false;
} else {
movedObjects.add(members[i]);
}
}
moveHandles = ParticipantTesting.createHandles(movedObjects.toArray());
}
RenameJavaElementDescriptor descriptor = createRefactoringDescriptor(thisPackage, newPackageName);
descriptor.setUpdateReferences(fUpdateReferences);
descriptor.setUpdateTextualOccurrences(fUpdateTextualMatches);
setFilePatterns(descriptor);
Refactoring refactoring = createRefactoring(descriptor);
RefactoringStatus result = performRefactoring(refactoring);
TestCase.assertEquals("preconditions were supposed to pass", null, result);
if (isRename) {
ParticipantTesting.testRename(renameHandles,
new RenameArguments[]{
new RenameArguments(newPackageName, fUpdateReferences),
new RenameArguments(target.getName(), fUpdateReferences)
}
);
} else {
ParticipantTesting.testRename(renameHandles,
new RenameArguments[]{
new RenameArguments(newPackageName, fUpdateReferences)});
ParticipantTesting.testCreate(createHandles);
List args = new ArrayList();
for (int i = 0; i < packageFileNames[0].length; i++) {
args.add(new MoveArguments(target, fUpdateReferences));
}
ParticipantTesting.testMove(moveHandles, (MoveArguments[])args.toArray(new MoveArguments[args.size()]));
if (doDelete) {
ParticipantTesting.testDelete(deleteHandles);
} else {
ParticipantTesting.testDelete(new String[0]);
}
}
//---
if (hasSubpackages) {
assertTrue("old package does not exist anymore", getRoot().getPackageFragment(packageNames[0]).exists());
} else {
assertTrue("package not renamed", !getRoot().getPackageFragment(packageNames[0]).exists());
}
IPackageFragment newPackage = getRoot().getPackageFragment(newPackageName);
assertTrue("new package does not exist", newPackage.exists());
for (int i = 0; i < packageFileNames.length; i++) {
String packageName = (i == 0)
? newPackageName.replace('.', '/') + "/"
: packageNames[i].replace('.', '/') + "/";
for (int j = 0; j < packageFileNames[i].length; j++) {
String s1 = getFileContents(getOutputTestFileName(packageFileNames[i][j], packageName));
ICompilationUnit cu =
(i == 0)
? newPackage.getCompilationUnit(packageFileNames[i][j] + ".java")
: cus[i][j];
//DebugUtils.dump("cu:" + cu.getElementName());
String s2 = cu.getSource();
//DebugUtils.dump("expected:" + s1);
//DebugUtils.dump("was:" + s2);
assertEqualLines("invalid update in file " + cu.getElementName(), s1, s2);
}
}
RefactoringProcessor processor = ((ProcessorBasedRefactoring)refactoring).getProcessor();
return (RenamePackageProcessor)processor;
}
private void performUndo() throws Exception {
IUndoManager um = RefactoringCore.getUndoManager();
assertTrue(um.anythingToUndo());
um.performUndo(null, new NullProgressMonitor());
assertFalse(um.anythingToUndo());
assertTrue(um.anythingToRedo());
}
/**
* Custom project and source folder structure.
*
* @param roots source folders
* @param packageNames package names per root
* @param newPackageName the new package name for packageNames[0][0]
* @param cuNames cu names per package
* @throws Exception if one of the resources cannot be created
*/
private void helperMultiProjects(IPackageFragmentRoot[] roots, String[][] packageNames, String newPackageName, String[][][] cuNames)
throws Exception {
ICompilationUnit[][][] cus = new ICompilationUnit[roots.length][][];
IPackageFragment thisPackage = null;
for (int r = 0; r < roots.length; r++) {
IPackageFragment[] packages = new IPackageFragment[packageNames[r].length];
cus[r] = new ICompilationUnit[packageNames[r].length][];
for (int pa = 0; pa < packageNames[r].length; pa++) {
packages[pa] = roots[r].createPackageFragment(packageNames[r][pa], true, null);
cus[r][pa] = new ICompilationUnit[cuNames[r][pa].length];
if (r == 0 && pa == 0)
thisPackage = packages[pa];
for (int typ = 0; typ < cuNames[r][pa].length; typ++) {
cus[r][pa][typ] = createCUfromTestFile(packages[pa], cuNames[r][pa][typ],
roots[r].getElementName() + "/" + packageNames[r][pa].replace('.', '/') + "/");
}
}
}
RenameJavaElementDescriptor descriptor = createRefactoringDescriptor(thisPackage, newPackageName);
descriptor.setUpdateReferences(fUpdateReferences);
descriptor.setUpdateTextualOccurrences(fUpdateTextualMatches);
setFilePatterns(descriptor);
descriptor.setUpdateHierarchy(fRenameSubpackages);
RefactoringStatus result = performRefactoring(descriptor);
TestCase.assertEquals("preconditions were supposed to pass", null, result);
assertTrue("package not renamed", !roots[0].getPackageFragment(packageNames[0][0]).exists());
IPackageFragment newPackage = roots[0].getPackageFragment(newPackageName);
assertTrue("new package does not exist", newPackage.exists());
for (int r = 0; r < cuNames.length; r++) {
for (int pa = 0; pa < cuNames[r].length; pa++) {
String packageName = roots[r].getElementName() + "/" +
((r == 0 && pa == 0) ? newPackageName : packageNames[r][pa]).replace('.', '/') + "/";
for (int typ = 0; typ < cuNames[r][pa].length; typ++) {
String s1 = getFileContents(getOutputTestFileName(cuNames[r][pa][typ], packageName));
ICompilationUnit cu = (r == 0 && pa == 0)
? newPackage.getCompilationUnit(cuNames[r][pa][typ] + ".java")
: cus[r][pa][typ];
//DebugUtils.dump("cu:" + cu.getElementName());
String s2 = cu.getSource();
//DebugUtils.dump("expected:" + s1);
//DebugUtils.dump("was:" + s2);
assertEqualLines("invalid update in file " + cu.toString(), s1, s2);
}
}
}
}
/**
* 2 Projects with a root each: Project RenamePack2 (root: srcTest) requires project RenamePack1
* (root: srcPrg).
*
* @param packageNames package names per root
* @param newPackageName the new package name for packageNames[0][0]
* @param cuNames cu names per package
* @throws Exception if one of the resources cannot be created
*/
private void helperProjectsPrgTest(String[][] packageNames, String newPackageName, String[][][] cuNames) throws Exception {
IJavaProject projectPrg = null;
IJavaProject projectTest = null;
try {
projectPrg = JavaProjectHelper.createJavaProject("RenamePack1", "bin");
assertNotNull(JavaProjectHelper.addRTJar(projectPrg));
IPackageFragmentRoot srcPrg = JavaProjectHelper.addSourceContainer(projectPrg, "srcPrg");
Map optionsPrg = projectPrg.getOptions(false);
JavaProjectHelper.set15CompilerOptions(optionsPrg);
projectPrg.setOptions(optionsPrg);
projectTest = JavaProjectHelper.createJavaProject("RenamePack2", "bin");
assertNotNull(JavaProjectHelper.addRTJar(projectTest));
IPackageFragmentRoot srcTest = JavaProjectHelper.addSourceContainer(projectTest, "srcTest");
Map optionsTest = projectTest.getOptions(false);
JavaProjectHelper.set15CompilerOptions(optionsTest);
projectTest.setOptions(optionsTest);
JavaProjectHelper.addRequiredProject(projectTest, projectPrg);
helperMultiProjects(new IPackageFragmentRoot[]{srcPrg, srcTest}, packageNames, newPackageName, cuNames);
} finally {
JavaProjectHelper.delete(projectPrg);
JavaProjectHelper.delete(projectTest);
}
}
/*
* Multiple source folders in the same project.
* @param newPackageName the new package name for packageNames[0][0]
*/
private void helperMultiRoots(String[] rootNames, String[][] packageNames, String newPackageName, String[][][] typeNames)
throws Exception {
IPackageFragmentRoot[] roots = new IPackageFragmentRoot[rootNames.length];
try {
for (int r = 0; r < roots.length; r++)
roots[r] = JavaProjectHelper.addSourceContainer(getRoot().getJavaProject(), rootNames[r]);
helperMultiProjects(roots, packageNames, newPackageName, typeNames);
} catch (CoreException e) {
}
for (int r = 0; r < roots.length; r++)
JavaProjectHelper.removeSourceContainer(getRoot().getJavaProject(), rootNames[r]);
}
private void setFilePatterns(RenameJavaElementDescriptor descriptor) {
descriptor.setUpdateQualifiedNames(fQualifiedNamesFilePatterns != null);
if (fQualifiedNamesFilePatterns != null)
descriptor.setFileNamePatterns(fQualifiedNamesFilePatterns);
}
private void checkMappingUnchanged(IJavaElementMapper jm, IResourceMapper rm, Object[] resOrJEs) {
for (int i = 0; i < resOrJEs.length; i++) {
Object resOrJE = resOrJEs[i];
if (resOrJE instanceof IJavaElement) {
IJavaElement javaElement = (IJavaElement)resOrJE;
resOrJE = javaElement.getResource();
TestCase.assertEquals(javaElement, jm.getRefactoredJavaElement(javaElement));
}
if (resOrJE instanceof IResource) {
IResource resource = (IResource)resOrJE;
TestCase.assertEquals(resource, rm.getRefactoredResource(resource));
}
}
}
private void checkMappingChanged(IJavaElementMapper jm, IResourceMapper rm, Object[][] resOrJeToChangeds) {
for (int i = 0; i < resOrJeToChangeds.length; i++) {
Object[] resOrJeToChanged = resOrJeToChangeds[i];
Object resOrJE = resOrJeToChanged[0];
Object changed = resOrJeToChanged[1];
if (resOrJE instanceof IJavaElement) {
IJavaElement javaElement = (IJavaElement)resOrJE;
TestCase.assertEquals(changed, jm.getRefactoredJavaElement(javaElement));
resOrJE = javaElement.getResource();
changed = ((IJavaElement)resOrJeToChanged[1]).getResource();
}
if (resOrJE instanceof IResource) {
IResource resource = (IResource)resOrJE;
TestCase.assertEquals(changed, rm.getRefactoredResource(resource));
}
}
}
@Test
public void testPackageRenameWithResource1() throws Exception {
IPackageFragment fragment = getRoot().createPackageFragment("org.test", true, null);
StringBuffer buf = new StringBuffer();
buf.append("package org.test;\n");
buf.append("public class MyClass {\n");
buf.append(" org.test.MyClass me;\n");
buf.append("}\n");
fragment.createCompilationUnit("MyClass.java", buf.toString(), true, null);
IFile file = ((IFolder)getRoot().getResource()).getFile("x.properties");
byte[] content = "This is about 'org.test' and more".getBytes();
file.create(new ByteArrayInputStream(content), true, null);
file.refreshLocal(IResource.DEPTH_ONE, null);
RenameJavaElementDescriptor descriptor =
RefactoringSignatureDescriptorFactory.createRenameJavaElementDescriptor(IJavaRefactorings.RENAME_PACKAGE);
descriptor.setJavaElement(fragment);
descriptor.setNewName("org.test2");
descriptor.setUpdateReferences(true);
descriptor.setUpdateQualifiedNames(true);
descriptor.setFileNamePatterns("*.properties");
Refactoring refactoring = createRefactoring(descriptor);
RefactoringStatus status = performRefactoring(refactoring);
if (status != null)
assertTrue(status.toString(), status.isOK());
RefactoringProcessor processor = ((RenameRefactoring)refactoring).getProcessor();
IResourceMapper rm = (IResourceMapper)processor.getAdapter(IResourceMapper.class);
IJavaElementMapper jm = (IJavaElementMapper)processor.getAdapter(IJavaElementMapper.class);
checkMappingUnchanged(jm, rm, new Object[]{getRoot().getJavaProject(), getRoot(), file});
IFile newFile = ((IContainer)getRoot().getResource()).getFile(new Path("x.properties"));
assertEquals("This is about 'org.test2' and more", getContents(newFile));
checkMappingChanged(jm, rm, new Object[][]{
{fragment, getRoot().getPackageFragment("org.test2")}
});
}
// ---------- tests -------------
@Test
public void testPackageRenameWithResource2() throws Exception {
IPackageFragment fragment = getRoot().createPackageFragment("org.test", true, null);
StringBuffer buf = new StringBuffer();
buf.append("package org.test;\n");
buf.append("public class MyClass {\n");
buf.append("}\n");
fragment.createCompilationUnit("MyClass.java", buf.toString(), true, null);
IFile file = ((IFolder)fragment.getResource()).getFile("x.properties");
byte[] content = "This is about 'org.test' and more".getBytes();
file.create(new ByteArrayInputStream(content), true, null);
file.refreshLocal(IResource.DEPTH_ONE, null);
RenameJavaElementDescriptor descriptor =
RefactoringSignatureDescriptorFactory.createRenameJavaElementDescriptor(IJavaRefactorings.RENAME_PACKAGE);
descriptor.setJavaElement(fragment);
descriptor.setNewName("org.test2");
descriptor.setUpdateReferences(true);
descriptor.setUpdateHierarchy(true);
descriptor.setUpdateQualifiedNames(true);
descriptor.setFileNamePatterns("*.properties");
Refactoring refactoring = createRefactoring(descriptor);
RefactoringStatus status = performRefactoring(refactoring);
if (status != null)
assertTrue(status.toString(), status.isOK());
RefactoringProcessor processor = ((RenameRefactoring)refactoring).getProcessor();
IResourceMapper rm = (IResourceMapper)processor.getAdapter(IResourceMapper.class);
IJavaElementMapper jm = (IJavaElementMapper)processor.getAdapter(IJavaElementMapper.class);
checkMappingUnchanged(jm, rm, new Object[]{getRoot().getJavaProject(), getRoot()});
IPackageFragment newFragment = getRoot().getPackageFragment("org.test2");
IFile newFile = ((IContainer)newFragment.getResource()).getFile(new Path("x.properties"));
assertEquals("This is about 'org.test2' and more", getContents(newFile));
checkMappingChanged(jm, rm, new Object[][]{
{file, newFile}
});
}
@Test
@Ignore
public void testPackageRenameWithResource3() throws Exception {
// regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=108019
fIsPreDeltaTest = true;
fQualifiedNamesFilePatterns = "*.txt";
String textFileName = "Textfile.txt";
String textfileContent = getFileContents(getTestPath() + name.getMethodName() + TEST_INPUT_INFIX + "my/pack/" + textFileName);
IFolder myPackFolder = getRoot().getJavaProject().getProject().getFolder("my").getFolder("pack");
CoreUtility.createFolder(myPackFolder, true, true, null);
IFile textfile = myPackFolder.getFile(textFileName);
textfile.create(new ByteArrayInputStream(textfileContent.getBytes()), true, null);
helper2(new String[]{"my.pack", "my"}, new String[][]{{}, {}}, "my");
InputStreamReader reader = new InputStreamReader(textfile.getContents(true));
StringBuffer newContent = new StringBuffer();
try {
int ch;
while ((ch = reader.read()) != -1)
newContent.append((char)ch);
} finally {
reader.close();
}
String definedContent = getFileContents(getTestPath() + name.getMethodName() + TEST_OUTPUT_INFIX + "my/" + textFileName);
assertEqualLines("invalid updating", definedContent, newContent.toString());
}
@Test
public void testHierarchical01() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(new String[]{"my", "my.a", "my.b"}, new String[][]{{"MyA"}, {"ATest"}, {"B"}}, "your");
IPackageFragment thisPackage = rename.fPackages[0];
ParticipantTesting.reset();
List toRename = new ArrayList(Arrays.asList(JavaElementUtil.getPackageAndSubpackages(thisPackage)));
toRename.add(thisPackage.getResource());
String[] renameHandles = ParticipantTesting.createHandles(toRename.toArray());
rename.execute();
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[2]), true),
new RenameArguments("your", true)
});
}
@Test
@Ignore
public void testHierarchical02() throws Exception {
if (BUG_PACKAGE_CANT_BE_RENAMED_TO_A_PACKAGE_THAT_ALREADY_EXISTS) {
printTestDisabledMessage("package can't be renamed to a package that already exists.");
return;
}
fRenameSubpackages = true;
PackageRename rename =
new PackageRename(new String[]{"my", "my.a", "my.b", "your"}, new String[][]{{"MyA"}, {"ATest"}, {"B"}, {"Y"}}, "your");
IPackageFragment thisPackage = rename.fPackages[0];
IPath srcPath = thisPackage.getParent().getPath();
IFolder target = ResourcesPlugin.getWorkspace().getRoot().getFolder(srcPath.append("your"));
ParticipantTesting.reset();
String[] createHandles = ParticipantTesting.createHandles(target.getFolder("a"), target.getFolder("b"));
String[] deleteHandles = ParticipantTesting.createHandles(thisPackage.getResource());
String[] moveHandles = ParticipantTesting.createHandles(new Object[]{
rename.fCus[0][0].getResource(),
rename.fCus[1][0].getResource(),
rename.fCus[2][0].getResource(),
});
String[] renameHandles = ParticipantTesting.createHandles(JavaElementUtil.getPackageAndSubpackages(thisPackage));
rename.execute();
ParticipantTesting.testCreate(createHandles);
ParticipantTesting.testDelete(deleteHandles);
ParticipantTesting.testMove(moveHandles, new MoveArguments[]{
new MoveArguments(target, true),
new MoveArguments(target.getFolder("a"), true),
new MoveArguments(target.getFolder("b"), true),
});
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[2]), true),
});
}
@Test
@Ignore
public void testHierarchical03() throws Exception {
fRenameSubpackages = true;
fUpdateTextualMatches = true;
PackageRename rename = new PackageRename(new String[]{"my", "my.pack"}, new String[][]{{}, {"C"}}, "your");
IPackageFragment thisPackage = rename.fPackages[0];
ParticipantTesting.reset();
List toRename = new ArrayList(Arrays.asList(JavaElementUtil.getPackageAndSubpackages(thisPackage)));
toRename.add(thisPackage.getResource());
String[] createHandles = {};
String[] deleteHandles = {};
String[] moveHandles = {};
String[] renameHandles = ParticipantTesting.createHandles(toRename.toArray());
rename.execute();
ParticipantTesting.testCreate(createHandles);
ParticipantTesting.testDelete(deleteHandles);
ParticipantTesting.testMove(moveHandles, new MoveArguments[]{
});
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
new RenameArguments("your", true)
});
}
@Test
@Ignore
public void testHierarchicalToSubpackage() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(
new String[]{"a", "a.b", "a.b.c", "a.b.c.d", "p"},
new String[][]{{}, {"B"}, {"C"}, {"D"}},
"a.b",
true
);
IPackageFragment thisPackage = rename.fPackages[0];
IFolder src = (IFolder)getRoot().getResource();
IFolder ab = src.getFolder("a/b");
IFolder abc = ab.getFolder("c");
IFolder abcd = abc.getFolder("d");
IFolder abb = ab.getFolder("b");
IFolder abbc = abb.getFolder("c");
IFolder abbcd = abbc.getFolder("d");
ParticipantTesting.reset();
String[] createHandles = ParticipantTesting.createHandles(abb, abbc, abbcd);
String[] deleteHandles = {};
String[] moveHandles = ParticipantTesting.createHandles(ab.getFile("B.java"), abc.getFile("C.java"), abcd.getFile("D.java"));
String[] renameHandles = ParticipantTesting.createHandles(JavaElementUtil.getPackageAndSubpackages(thisPackage));
rename.createAndPerform(RefactoringStatus.WARNING);
rename.checkExpectedState();
ParticipantTesting.testCreate(createHandles);
ParticipantTesting.testDelete(deleteHandles);
ParticipantTesting.testMove(moveHandles, new MoveArguments[]{
new MoveArguments(abb, true),
new MoveArguments(abbc, true),
new MoveArguments(abbcd, true),
});
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[2]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[3]), true),
});
performUndo();
rename.checkOriginalState();
}
@Test
@Ignore
public void testHierarchicalToSuperpackage() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(
new String[]{"a.b", "a.b.b", "a", "p"},
new String[][]{{"B"}, {"BB"}, {}},
"a",
true
);
IPackageFragment thisPackage = rename.fPackages[0];
IFolder src = (IFolder)getRoot().getResource();
IFolder a = src.getFolder("a");
IFolder ab = src.getFolder("a/b");
IFolder abb = src.getFolder("a/b/b");
ParticipantTesting.reset();
String[] createHandles = {};
String[] deleteHandles = {};
String[] moveHandles = ParticipantTesting.createHandles(ab.getFile("B.java"), abb.getFile("BB.java"));
String[] renameHandles = ParticipantTesting.createHandles(JavaElementUtil.getPackageAndSubpackages(thisPackage));
rename.createAndPerform(RefactoringStatus.OK);
rename.checkExpectedState();
ParticipantTesting.testCreate(createHandles);
ParticipantTesting.testDelete(deleteHandles);
ParticipantTesting.testMove(moveHandles, new MoveArguments[]{
new MoveArguments(a, true),
new MoveArguments(ab, true),
});
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments("a", true),
new RenameArguments("a.b", true),
});
performUndo();
rename.checkOriginalState();
}
@Test
@Ignore
public void testHierarchicalToSuperpackage2() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(
new String[]{"a.b", "a.b.c", "a.c", "p"},
new String[][]{{"B"}, {"BC"}, {}},
"a",
true
);
IPackageFragment thisPackage = rename.fPackages[0];
IFolder src = (IFolder)getRoot().getResource();
IFolder a = src.getFolder("a");
IFolder ab = src.getFolder("a/b");
IFolder ac = src.getFolder("a/c");
IFolder abc = src.getFolder("a/b/c");
ParticipantTesting.reset();
String[] createHandles = {};
String[] deleteHandles = ParticipantTesting.createHandles(ab);
String[] moveHandles = ParticipantTesting.createHandles(ab.getFile("B.java"), abc.getFile("BC.java"));
String[] renameHandles = ParticipantTesting.createHandles(JavaElementUtil.getPackageAndSubpackages(thisPackage));
rename.createAndPerform(RefactoringStatus.OK);
rename.checkExpectedState();
ParticipantTesting.testCreate(createHandles);
ParticipantTesting.testDelete(deleteHandles);
ParticipantTesting.testMove(moveHandles, new MoveArguments[]{
new MoveArguments(a, true),
new MoveArguments(ac, true),
});
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments("a", true),
new RenameArguments("a.c", true),
});
performUndo();
rename.fPackageNames = new String[]{"a.b", "a.b.c", "a", "p"};// empty package is not recreated, but that's OK
rename.checkOriginalState();
}
@Test
public void testHierarchicalToSuperpackageFail() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(
new String[]{"a.b", "a.b.c", "a.c", "a", "p"},
new String[][]{{"B"}, {"BC"}, {"AC"}},
"a",
true
);
rename.createAndPerform(RefactoringStatus.FATAL);
rename.checkOriginalState();
}
@Test
public void testHierarchicalDisabledImport() throws Exception {
fRenameSubpackages = true;
fUpdateTextualMatches = true;
PackageRename rename = new PackageRename(new String[]{"my", "my.pack"}, new String[][]{{}, {"C"}}, "your");
IPackageFragment thisPackage = rename.fPackages[0];
ParticipantTesting.reset();
List toRename = new ArrayList(Arrays.asList(JavaElementUtil.getPackageAndSubpackages(thisPackage)));
toRename.add(thisPackage.getResource());
String[] renameHandles = ParticipantTesting.createHandles(toRename.toArray());
rename.execute();
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
new RenameArguments("your", true)
});
}
@Test
public void testFail0() throws Exception {
helper1(new String[]{"r"}, new String[][]{{"A"}}, "9");
}
// public void testHierarchicalJUnit() throws Exception {
// fRenameSubpackages= true;
//
// File junitSrcArchive= JavaTestPlugin.getDefault().getFileInPlugin(JavaProjectHelper.JUNIT_SRC_381);
// assertTrue(junitSrcArchive != null && junitSrcArchive.exists());
// IPackageFragmentRoot src= JavaProjectHelper.addSourceContainerWithImport(getRoot().getJavaProject(), "src", junitSrcArchive,
// JavaProjectHelper.JUNIT_SRC_ENCODING);
//
// String[] packageNames= new String[]{"junit", "junit.extensions", "junit.framework", "junit.runner", "junit.samples", "junit
// .samples.money", "junit.tests", "junit.tests.extensions", "junit.tests.framework", "junit.tests.runner", "junit.textui"};
// ICompilationUnit[][] cus= new ICompilationUnit[packageNames.length][];
// for (int i= 0; i < cus.length; i++) {
// cus[i]= src.getPackageFragment(packageNames[i]).getCompilationUnits();
// }
// IPackageFragment thisPackage= src.getPackageFragment("junit");
//
// ParticipantTesting.reset();
// PackageRename rename= new PackageRename(packageNames, new String[packageNames.length][0],"jdiverge");
//
// RenameArguments[] renameArguments= new RenameArguments[packageNames.length + 1];
// for (int i= 0; i < packageNames.length; i++) {
// renameArguments[i]= new RenameArguments(rename.getNewPackageName(packageNames[i]), true);
// }
// renameArguments[packageNames.length]= new RenameArguments("jdiverge", true);
// String[] renameHandles= new String[packageNames.length + 1];
// System.arraycopy(ParticipantTesting.createHandles(JavaElementUtil.getPackageAndSubpackages(thisPackage)), 0, renameHandles, 0,
// packageNames.length);
// renameHandles[packageNames.length]= ParticipantTesting.createHandles(thisPackage.getResource())[0];
//
// // --- execute:
// RenameJavaElementDescriptor descriptor= createRefactoringDescriptor(thisPackage, "jdiverge");
// descriptor.setUpdateReferences(fUpdateReferences);
// descriptor.setUpdateTextualOccurrences(fUpdateTextualMatches);
// setFilePatterns(descriptor);
// descriptor.setUpdateHierarchy(fRenameSubpackages);
// Refactoring ref= createRefactoring(descriptor);
//
// performDummySearch();
// IUndoManager undoManager= getUndoManager();
// CreateChangeOperation create= new CreateChangeOperation(
// new CheckConditionsOperation(ref, CheckConditionsOperation.ALL_CONDITIONS),
// RefactoringStatus.FATAL);
// PerformChangeOperation perform= new PerformChangeOperation(create);
// perform.setUndoManager(undoManager, ref.getName());
// ResourcesPlugin.getWorkspace().run(perform, new NullProgressMonitor());
// RefactoringStatus status= create.getConditionCheckingStatus();
// assertTrue("Change wasn't executed", perform.changeExecuted());
// Change undo= perform.getUndoChange();
// assertNotNull("Undo doesn't exist", undo);
// assertTrue("Undo manager is empty", undoManager.anythingToUndo());
//
// assertFalse(status.hasError());
// assertTrue(status.hasWarning());
// RefactoringStatusEntry[] statusEntries= status.getEntries();
// for (int i= 0; i < statusEntries.length; i++) {
// RefactoringStatusEntry entry= statusEntries[i];
// assertTrue(entry.isWarning());
// assertTrue(entry.getCode() == RefactoringStatusCodes.MAIN_METHOD);
// }
//
// assertTrue("package not renamed: " + rename.fPackageNames[0], ! src.getPackageFragment(rename.fPackageNames[0]).exists());
// IPackageFragment newPackage= src.getPackageFragment(rename.fNewPackageName);
// assertTrue("new package does not exist", newPackage.exists());
// // ---
//
// ParticipantTesting.testRename(renameHandles, renameArguments);
//
// PerformChangeOperation performUndo= new PerformChangeOperation(undo);
// ResourcesPlugin.getWorkspace().run(performUndo, new NullProgressMonitor());
//
// assertTrue("new package still exists", ! newPackage.exists());
// assertTrue("original package does not exist: " + rename.fPackageNames[0], src.getPackageFragment(rename.fPackageNames[0]).exists
// ());
//
// ZipInputStream zis= new ZipInputStream(new BufferedInputStream(new FileInputStream(junitSrcArchive)));
// ZipTools.compareWithZipped(src, zis, JavaProjectHelper.JUNIT_SRC_ENCODING);
// }
public void testFail1() throws Exception {
printTestDisabledMessage("needs revisiting");
//helper1(new String[]{"r.p1"}, new String[][]{{"A"}}, "r");
}
@Test
public void testFail3() throws Exception {
helper1(new String[]{"r"}, new String[][]{{"A"}}, "fred");
}
@Test
public void testFail4() throws Exception {
helper1();
}
@Test
public void testFail5() throws Exception {
helper1();
}
@Test
public void testFail6() throws Exception {
helper1();
}
public void testFail7() throws Exception {
//printTestDisabledMessage("1GK90H4: ITPJCORE:WIN2000 - search: missing package reference");
printTestDisabledMessage("corner case - name obscuring");
// helper1(new String[]{"r", "p1"}, new String[][]{{"A"}, {"A"}}, "fred");
}
public void testFail8() throws Exception {
printTestDisabledMessage("corner case - name obscuring");
// helper1(new String[]{"r", "p1"}, new String[][]{{"A"}, {"A"}}, "fred");
}
//native method used r.A as a parameter
public void testFail9() throws Exception {
printTestDisabledMessage("corner case - qualified name used as a parameter of a native method");
//helper1(new String[]{"r", "p1"}, new String[][]{{"A"}, {"A"}}, "fred");
}
public void testFail10() throws Exception {
helper1(new String[]{"r.p1", "r"}, new String[][]{{"A"}, {"A"}}, "r");
}
@Test
public void test0() throws Exception {
if (BUG_54962_71267) {
printTestDisabledMessage("bugs 54962, 71267");
return;
}
fIsPreDeltaTest = true;
}
//-------
@Test
public void test1() throws Exception {
fIsPreDeltaTest = true;
RenamePackageProcessor proc = helper2(new String[]{"r"}, new String[][]{{"A"}}, "p1");
IJavaElementMapper jm = (IJavaElementMapper)proc.getAdapter(IJavaElementMapper.class);
IResourceMapper rm = (IResourceMapper)proc.getAdapter(IResourceMapper.class);
IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
IJavaProject project = getRoot().getJavaProject();
IFile _project = project.getProject().getFile(".project");
checkMappingUnchanged(jm, rm, new Object[]{project, _project, getRoot(), getPackageP(),
getRoot().getPackageFragment("inexistent"), getRoot().getPackageFragment("r.inexistent"),
getRoot().getPackageFragment("p1.inexistent")});
IPackageFragment r = getRoot().getPackageFragment("p1");
ICompilationUnit r_A = r.getCompilationUnit("A.java");
IType r_A_A = r_A.getType("A");
IField r_A_A_a = r_A_A.getField("a");
IPackageFragment p1 = getRoot().getPackageFragment("p1");
ICompilationUnit p1_A = p1.getCompilationUnit("A.java");
IType p1_A_A = p1_A.getType("A");
IField p1_A_A_a = p1_A_A.getField("a");
checkMappingChanged(jm, rm, new Object[][]{
{r, p1},
{r_A, p1_A},
{r_A_A, p1_A_A},
{r_A_A_a, p1_A_A_a},
});
}
@Test
public void test2() throws Exception {
fIsPreDeltaTest = true;
RenamePackageProcessor processor = helper2(new String[]{"r", "fred"}, new String[][]{{"A"}, {"A"}}, "p1");
// test that participants are correctly informed after '< Back': https://bugs.eclipse.org/bugs/show_bug.cgi?id=280068
performUndo();
ParticipantTesting.reset();
String secondName = "pipapo";
processor.setNewElementName(secondName);
String[] renameHandles = ParticipantTesting.createHandles(new Object[]{
processor.getPackage(),
processor.getPackage().getResource()
});
RenameRefactoring refactoring = (RenameRefactoring)processor.getRefactoring();
refactoring.checkFinalConditions(new NullProgressMonitor());
refactoring.createChange(new NullProgressMonitor());
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(secondName, true),
new RenameArguments(secondName, true)
});
}
@Test
@Ignore
public void test3() throws Exception {
fIsPreDeltaTest = true;
helper2(new String[]{"fred", "r.r"}, new String[][]{{"A"}, {"B"}}, "r");
}
@Test
public void test4() throws Exception {
fIsPreDeltaTest = true;
fQualifiedNamesFilePatterns = "*.txt";
String textFileName = "Textfile.txt";
String textfileContent = getFileContents(getTestPath() + name.getMethodName() + TEST_INPUT_INFIX + textFileName);
IFile textfile = getRoot().getJavaProject().getProject().getFile(textFileName);
textfile.create(new ByteArrayInputStream(textfileContent.getBytes()), true, null);
helper2(new String[]{"r.p1", "r"}, new String[][]{{"A"}, {"A"}}, "q");
InputStreamReader reader = new InputStreamReader(textfile.getContents(true));
StringBuffer newContent = new StringBuffer();
try {
int ch;
while ((ch = reader.read()) != -1)
newContent.append((char)ch);
} finally {
reader.close();
}
String definedContent = getFileContents(getTestPath() + name.getMethodName() + TEST_OUTPUT_INFIX + textFileName);
assertEqualLines("invalid updating", definedContent, newContent.toString());
}
@Test
public void test5() throws Exception {
fUpdateReferences = false;
fIsPreDeltaTest = true;
helper2(new String[]{"r"}, new String[][]{{"A"}}, "p1");
}
@Test
public void test6() throws Exception { //bug 66250
fUpdateReferences = false;
fUpdateTextualMatches = true;
fIsPreDeltaTest = true;
helper2(new String[]{"r"}, new String[][]{{"A"}}, "p1");
}
@Test
public void test7() throws Exception {
helper2(new String[]{"r", "r.s"}, new String[][]{{"A"}, {"B"}}, "q");
}
@Test
@Ignore
public void test8() throws Exception {
helper2(new String[]{"java.lang.reflect"}, new String[][]{{"Klass"}}, "nonjava");
}
@Test
@Ignore
public void testToEmptyPack() throws Exception {
helper2(new String[]{"r.p1", "fred"}, new String[][]{{"A"}, {}}, "fred");
}
@Test
public void testToEmptySubPack() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(new String[]{"p", "p.q"}, new String[][]{{}, {}}, "p.q");
IPackageFragment p = rename.fPackages[0];
IPackageFragment pq = rename.fPackages[1];
ParticipantTesting.reset();
String[] renameHandles = ParticipantTesting.createHandles(p, pq);
rename.createAndPerform(RefactoringStatus.OK);
assertTrue(p.exists());
assertTrue(pq.exists());
IPackageFragment ppq = getRoot().getPackageFragment("p.q.q");
assertTrue(ppq.exists());
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
});
ParticipantTesting.testCreate(ParticipantTesting.createHandles(
ppq.getResource()
));
}
@Test
public void testWithEmptySubPack() throws Exception {
fRenameSubpackages = true;
PackageRename rename = new PackageRename(new String[]{"p", "p.q"}, new String[][]{{}, {}}, "p1");
IPackageFragment p = rename.fPackages[0];
IPackageFragment pq = rename.fPackages[1];
ParticipantTesting.reset();
String[] renameHandles = ParticipantTesting.createHandles(p, pq, p.getResource());
rename.createAndPerform(RefactoringStatus.OK);
assertFalse(p.exists());
assertFalse(pq.exists());
IPackageFragment p1 = getRoot().getPackageFragment("p1");
IPackageFragment p1q = getRoot().getPackageFragment("p1.q");
assertTrue(p1.exists());
assertTrue(p1q.exists());
ParticipantTesting.testRename(renameHandles, new RenameArguments[]{
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[0]), true),
new RenameArguments(rename.getNewPackageName(rename.fPackageNames[1]), true),
new RenameArguments("p1", true)
});
}
@Test
public void testReadOnly() throws Exception {
if (BUG_6054) {
printTestDisabledMessage("see bug#6054 (renaming a read-only package resets the read-only flag)");
return;
}
fIsPreDeltaTest = true;
String[] packageNames = new String[]{"r"};
String[][] packageFileNames = new String[][]{{"A"}};
String newPackageName = "p1";
IPackageFragment[] packages = new IPackageFragment[packageNames.length];
ICompilationUnit[][] cus = new ICompilationUnit[packageFileNames.length][packageFileNames[0].length];
for (int i = 0; i < packageNames.length; i++) {
packages[i] = getRoot().createPackageFragment(packageNames[i], true, null);
for (int j = 0; j < packageFileNames[i].length; j++) {
cus[i][j] = createCUfromTestFile(packages[i], packageFileNames[i][j], packageNames[i].replace('.', '/') + "/");
}
}
IPackageFragment thisPackage = packages[0];
final IResource resource = thisPackage.getCorrespondingResource();
final ResourceAttributes attributes = resource.getResourceAttributes();
if (attributes != null)
attributes.setReadOnly(true);
RefactoringStatus result = performRefactoring(createRefactoringDescriptor(thisPackage, newPackageName));
TestCase.assertEquals("preconditions were supposed to pass", null, result);
assertTrue("package not renamed", !getRoot().getPackageFragment(packageNames[0]).exists());
IPackageFragment newPackage = getRoot().getPackageFragment(newPackageName);
assertTrue("new package does not exist", newPackage.exists());
assertTrue("new package should be read-only", attributes == null || attributes.isReadOnly());
}
@Test
@Ignore
public void testImportFromMultiRoots1() throws Exception {
fUpdateTextualMatches = true;
helperProjectsPrgTest(
new String[][]{
new String[]{"p.p"}, new String[]{"p.p", "tests"}
},
"q",
new String[][][]{
new String[][]{new String[]{"A"}},
new String[][]{new String[]{"ATest"}, new String[]{"AllTests"}}
});
}
@Test
@Ignore
public void testImportFromMultiRoots2() throws Exception {
helperProjectsPrgTest(
new String[][]{
new String[]{"p.p"},
new String[]{"p.p", "tests"}
},
"q",
new String[][][]{
new String[][]{new String[]{"A"}},
new String[][]{new String[]{"ATest", "TestHelper"}, new String[]{"AllTests", "QualifiedTests"}}
}
);
}
@Test
@Ignore
public void testImportFromMultiRoots3() throws Exception {
helperMultiRoots(new String[]{"srcPrg", "srcTest"},
new String[][]{
new String[]{"p.p"},
new String[]{"p.p"}
},
"q",
new String[][][]{
new String[][]{new String[]{"ToQ"}},
new String[][]{new String[]{"Ref"}}
}
);
}
@Test
@Ignore
public void testImportFromMultiRoots4() throws Exception {
//circular buildpath references
IJavaProject projectPrg = null;
IJavaProject projectTest = null;
Hashtable options = JavaCore.getOptions();
Object cyclicPref = JavaCore.getOption(JavaCore.CORE_CIRCULAR_CLASSPATH);
try {
projectPrg = JavaProjectHelper.createJavaProject("RenamePack1", "bin");
assertNotNull(JavaProjectHelper.addRTJar(projectPrg));
IPackageFragmentRoot srcPrg = JavaProjectHelper.addSourceContainer(projectPrg, "srcPrg");
projectTest = JavaProjectHelper.createJavaProject("RenamePack2", "bin");
assertNotNull(JavaProjectHelper.addRTJar(projectTest));
IPackageFragmentRoot srcTest = JavaProjectHelper.addSourceContainer(projectTest, "srcTest");
options.put(JavaCore.CORE_CIRCULAR_CLASSPATH, JavaCore.WARNING);
JavaCore.setOptions(options);
JavaProjectHelper.addRequiredProject(projectTest, projectPrg);
JavaProjectHelper.addRequiredProject(projectPrg, projectTest);
helperMultiProjects(new IPackageFragmentRoot[]{srcPrg, srcTest},
new String[][]{
new String[]{"p"},
new String[]{"p"}
},
"a.b.c",
new String[][][]{
new String[][]{new String[]{"A", "B"}},
new String[][]{new String[]{"ATest"}}
}
);
} finally {
options.put(JavaCore.CORE_CIRCULAR_CLASSPATH, cyclicPref);
JavaCore.setOptions(options);
JavaProjectHelper.delete(projectPrg);
JavaProjectHelper.delete(projectTest);
}
}
@Test
@Ignore
public void testImportFromMultiRoots5() throws Exception {
//rename srcTest-p.p to q => ATest now must import p.p.A
IJavaProject projectPrg = null;
IJavaProject projectTest = null;
try {
projectPrg = JavaProjectHelper.createJavaProject("RenamePack1", "bin");
assertNotNull(JavaProjectHelper.addRTJar(projectPrg));
IPackageFragmentRoot srcPrg = JavaProjectHelper.addSourceContainer(projectPrg, "srcPrg");
projectTest = JavaProjectHelper.createJavaProject("RenamePack2", "bin");
assertNotNull(JavaProjectHelper.addRTJar(projectTest));
IPackageFragmentRoot srcTest = JavaProjectHelper.addSourceContainer(projectTest, "srcTest");
JavaProjectHelper.addRequiredProject(projectTest, projectPrg);
helperMultiProjects(new IPackageFragmentRoot[]{srcTest, srcPrg},
new String[][]{
new String[]{"p.p"}, new String[]{"p.p"}
},
"q",
new String[][][]{
new String[][]{new String[]{"ATest"}},
new String[][]{new String[]{"A"}}
}
);
} finally {
JavaProjectHelper.delete(projectPrg);
JavaProjectHelper.delete(projectTest);
}
}
@Test
@Ignore
public void testImportFromMultiRoots6() throws Exception {
//rename srcTest-p.p to a.b.c => ATest must retain import p.p.A
helperMultiRoots(new String[]{"srcTest", "srcPrg"},
new String[][]{
new String[]{"p.p"},
new String[]{"p.p"}
},
"cheese",
new String[][][]{
new String[][]{new String[]{"ATest"}},
new String[][]{new String[]{"A"}}
}
);
}
@Test
@Ignore
public void testImportFromMultiRoots7() throws Exception {
IJavaProject prj = null;
IJavaProject prjRef = null;
IJavaProject prjOther = null;
try {
prj = JavaProjectHelper.createJavaProject("prj", "bin");
assertNotNull(JavaProjectHelper.addRTJar(prj));
IPackageFragmentRoot srcPrj = JavaProjectHelper.addSourceContainer(prj, "srcPrj"); //$NON-NLS-1$
prjRef = JavaProjectHelper.createJavaProject("prj.ref", "bin");
assertNotNull(JavaProjectHelper.addRTJar(prjRef));
IPackageFragmentRoot srcPrjRef = JavaProjectHelper.addSourceContainer(prjRef, "srcPrj.ref"); //$NON-NLS-1$
prjOther = JavaProjectHelper.createJavaProject("prj.other", "bin");
assertNotNull(JavaProjectHelper.addRTJar(prjOther));
IPackageFragmentRoot srcPrjOther = JavaProjectHelper.addSourceContainer(prjRef, "srcPrj.other"); //$NON-NLS-1$
JavaProjectHelper.addRequiredProject(prjRef, prj);
JavaProjectHelper.addRequiredProject(prjRef, prjOther);
helperMultiProjects(
new IPackageFragmentRoot[]{srcPrj, srcPrjRef, srcPrjOther},
new String[][]{
new String[]{"pack"},
new String[]{"pack", "pack.man"},
new String[]{"pack"}
},
"com.packt",
new String[][][]{
new String[][]{new String[]{"DingsDa"}},
new String[][]{new String[]{"Referer"}, new String[]{"StarImporter"}},
new String[][]{new String[]{"Namesake"}}
}
);
} finally {
JavaProjectHelper.delete(prj);
JavaProjectHelper.delete(prjRef);
JavaProjectHelper.delete(prjOther);
}
}
@Test
public void testStatic1() throws Exception {
helper2(new String[]{"s1.j.l", "s1"}, new String[][]{{"S"}, {"B"}}, "s1.java.lang");
}
@Test
@Ignore
public void testStaticMultiRoots1() throws Exception {
helperProjectsPrgTest(
new String[][]{
new String[]{"p.p"}, new String[]{"p.p", "tests"}
},
"q",
new String[][][]{
new String[][]{new String[]{"A"}},
new String[][]{new String[]{"ATest"}, new String[]{"AllTests"}}
});
}
class PackageRename {
final String[][] fPackageFileNames;
final String fNewPackageName;
final boolean fTestWithDummyFiles;
final IPackageFragment[] fPackages;
final ICompilationUnit[][] fCus;
String[] fPackageNames;
public PackageRename(String[] packageNames, String[][] packageFileNames, String newPackageName) throws Exception {
this(packageNames, packageFileNames, newPackageName, false);
}
public PackageRename(String[] packageNames, String[][] packageFileNames, String newPackageName, boolean testWithDummyFiles)
throws Exception {
fPackageNames = packageNames;
fPackageFileNames = packageFileNames;
fNewPackageName = newPackageName;
fTestWithDummyFiles = testWithDummyFiles;
fPackages = new IPackageFragment[packageNames.length];
fCus = new ICompilationUnit[packageFileNames.length][];
for (int i = 0; i < packageFileNames.length; i++) {
fPackages[i] = getRoot().createPackageFragment(packageNames[i], true, null);
fCus[i] = new ICompilationUnit[packageFileNames[i].length];
for (int j = 0; j < packageFileNames[i].length; j++) {
if (testWithDummyFiles) {
fCus[i][j] = createDummyCU(fPackages[i], packageFileNames[i][j]);
} else {
fCus[i][j] = createCUfromTestFile(fPackages[i], packageFileNames[i][j], packageNames[i].replace('.', '/') + "/");
}
}
}
}
private ICompilationUnit createDummyCU(IPackageFragment packageFragment, String typeName) throws JavaModelException {
String contents = getDummyContents(packageFragment.getElementName(), typeName);
return packageFragment.createCompilationUnit(typeName + ".java", contents, true, null);
}
private String getDummyContents(String packName, String typeName) {
StringBuffer contents = new StringBuffer();
if (packName.length() != 0)
contents.append("package ").append(packName).append(";\n");
contents.append("public class ").append(typeName).append(" { }\n");
return contents.toString();
}
public void createAndPerform(int expectedSeverity) throws CoreException, Exception {
IPackageFragment thisPackage = fPackages[0];
RenameJavaElementDescriptor descriptor = createRefactoringDescriptor(thisPackage, fNewPackageName);
descriptor.setUpdateReferences(fUpdateReferences);
descriptor.setUpdateTextualOccurrences(fUpdateTextualMatches);
setFilePatterns(descriptor);
descriptor.setUpdateHierarchy(fRenameSubpackages);
RefactoringStatus result = performRefactoring(descriptor);
if (expectedSeverity == RefactoringStatus.OK)
TestCase.assertEquals("preconditions were supposed to pass", null, result);
else
TestCase.assertEquals(expectedSeverity, result.getSeverity());
}
public void execute() throws Exception {
createAndPerform(RefactoringStatus.OK);
IPackageFragment oldPackage = getRoot().getPackageFragment(fPackageNames[0]);
assertTrue("package not renamed: " + fPackageNames[0], !oldPackage.exists());
IPackageFragment newPackage = getRoot().getPackageFragment(fNewPackageName);
assertTrue("new package does not exist", newPackage.exists());
checkExpectedState();
}
public void checkExpectedState() throws IOException, JavaModelException {
for (int i = 0; i < fPackageFileNames.length; i++) {
String packageName = getNewPackageName(fPackageNames[i]);
String packagePath = packageName.replace('.', '/') + "/";
for (int j = 0; j < fPackageFileNames[i].length; j++) {
String expected;
if (fTestWithDummyFiles) {
expected = getDummyContents(packageName, fPackageFileNames[i][j]);
} else {
expected = getFileContents(getOutputTestFileName(fPackageFileNames[i][j], packagePath));
}
ICompilationUnit cu = getRoot().getPackageFragment(packageName).getCompilationUnit(fPackageFileNames[i][j] + ".java");
String actual = cu.getSource();
assertEqualLines("invalid update in file " + cu.getElementName(), expected, actual);
}
}
}
public String getNewPackageName(String oldPackageName) {
if (oldPackageName.equals(fPackageNames[0]))
return fNewPackageName;
if (fRenameSubpackages && oldPackageName.startsWith(fPackageNames[0] + "."))
return fNewPackageName + oldPackageName.substring(fPackageNames[0].length());
return oldPackageName;
}
public void checkOriginalState() throws Exception {
IJavaElement[] rootChildren = getRoot().getChildren();
ArrayList existingPacks = new ArrayList();
for (int i = 0; i < rootChildren.length; i++) {
existingPacks.add(rootChildren[i].getElementName());
}
assertEqualSets(Arrays.asList(fPackageNames), existingPacks);
for (int i = 0; i < fPackageFileNames.length; i++) {
String packageName = fPackageNames[i];
String packagePath = packageName.replace('.', '/') + "/";
IPackageFragment pack = getRoot().getPackageFragment(packageName);
IJavaElement[] packChildren = pack.getChildren();
ArrayList existingCUs = new ArrayList();
for (int j = 0; j < packChildren.length; j++) {
String cuName = packChildren[j].getElementName();
existingCUs.add(cuName.substring(0, cuName.length() - 5));
}
assertEqualSets(Arrays.asList(fPackageFileNames[i]), existingCUs);
for (int j = 0; j < fPackageFileNames[i].length; j++) {
String expected;
if (fTestWithDummyFiles) {
expected = getDummyContents(packageName, fPackageFileNames[i][j]);
} else {
expected = getFileContents(getInputTestFileName(fPackageFileNames[i][j], packagePath));
}
ICompilationUnit cu = pack.getCompilationUnit(fPackageFileNames[i][j] + ".java");
String actual = cu.getSource();
assertEqualLines("invalid undo in file " + cu.getElementName(), expected, actual);
}
}
}
private void assertEqualSets(Collection expected, Collection actual) {
HashSet expectedSet = new HashSet(expected);
expectedSet.removeAll(actual);
TestCase.assertEquals("not all expected in actual", "[]", expectedSet.toString());
HashSet actualSet = new HashSet(actual);
actualSet.removeAll(expected);
TestCase.assertEquals("not all actual in expected", "[]", actualSet.toString());
}
}
}