RenamePackageTest.java

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