java/java-tests/testSrc/com/intellij/refactoring/MoveMembersTest.java

   1 /*
   2  * Copyright 2000-2014 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.refactoring;
  17
  18 import com.intellij.JavaTestUtil;
  19 import com.intellij.openapi.fileEditor.FileDocumentManager;
  20 import com.intellij.openapi.roots.LanguageLevelProjectExtension;
  21 import com.intellij.pom.java.LanguageLevel;
  22 import com.intellij.psi.PsiClass;
  23 import com.intellij.psi.PsiElement;
  24 import com.intellij.psi.PsiMember;
  25 import com.intellij.psi.PsiModifier;
  26 import com.intellij.psi.search.ProjectScope;
  27 import com.intellij.refactoring.move.moveMembers.MockMoveMembersOptions;
  28 import com.intellij.refactoring.move.moveMembers.MoveMembersProcessor;
  29 import com.intellij.util.VisibilityUtil;
  30 import org.jetbrains.annotations.NotNull;
  31
  32 import java.util.ArrayList;
  33 import java.util.LinkedHashSet;
  34
  35 public class MoveMembersTest extends MultiFileTestCase {
  36   @Override
  37   protected String getTestDataPath() {
  38     return JavaTestUtil.getJavaTestDataPath();
  39   }
  40
  41   public void testJavadocRefs() throws Exception {
  42     doTest("Class1", "Class2", 0);
  43   }
  44
  45   public void testWeirdDeclaration() throws Exception {
  46     doTest("A", "B", 0);
  47   }
  48
  49   public void testInnerClass() throws Exception {
  50     doTest("A", "B", 0);
  51   }
  52
  53   public void testScr11871() throws Exception {
  54     doTest("pack1.A", "pack1.B", 0);
  55   }
  56
  57   public void testOuterClassTypeParameters() throws Exception {
  58     doTest("pack1.A", "pack2.B", 0);
  59   }
  60
  61   public void testscr40064() throws Exception {
  62     doTest("Test", "Test1", 0);
  63   }
  64
  65   public void testscr40947() throws Exception {
  66     doTest("A", "Test", 0, 1);
  67   }
  68
  69   public void testIDEADEV11416() throws Exception {
  70     doTest("Y", "X", false, 0);
  71   }
  72
  73   public void testDependantConstants() throws Exception {
  74     doTest("A", "B", 0, 1);
  75   }
  76
  77   public void testTwoMethods() throws Exception {
  78     doTest("pack1.A", "pack1.C", 0, 1, 2);
  79   }
  80
  81   public void testParameterizedRefOn() throws Exception {
  82     doTest("pack1.POne", "pack1.C", 1, 2);
  83   }
  84
  85   public void testIDEADEV12448() throws Exception {
  86     doTest("B", "A", false, 0);
  87   }
  88
  89   public void testFieldForwardRef() throws Exception {
  90     doTest("A", "Constants", 0);
  91   }
  92
  93   public void testStaticImport() throws Exception {
  94     doTest("C", "B", 0);
  95   }
  96
  97   public void testExplicitStaticImport() throws Exception {
  98     doTest("C", "B", 0);
  99   }
 100
 101   public void testProtectedConstructor() throws Exception {
 102     doTest("pack1.A", "pack1.C", 0);
 103   }
 104
 105   public void testUntouchedVisibility() throws Exception {
 106     doTest("pack1.A", "pack1.C", 0, 1);
 107   }
 108
 109   public void testEscalateVisibility() throws Exception {
 110     doTest("pack1.A", "pack1.C", true, VisibilityUtil.ESCALATE_VISIBILITY, 0);
 111   }
 112
 113   public void testOtherPackageImport() throws Exception {
 114     doTest("pack1.ClassWithStaticMethod", "pack2.OtherClass", 1);
 115   }
 116
 117   public void testEnumConstant() throws Exception {
 118     doTest("B", "A", 0);
 119   }
 120
 121   public void testEnumConstantFromCaseStatement() throws Exception {
 122     doTest("B", "A", 0);
 123   }
 124
 125   public void testStringConstantFromCaseStatement() throws Exception {
 126     doTest("B", "A", 0);
 127   }
 128
 129   public void testDependantFields() throws Exception {
 130     doTest("B", "A", 0);
 131   }
 132
 133   public void testStaticImportAndOverridenMethods() throws Exception {
 134     doTest("bar.B", "bar.A", 0);
 135   }
 136
 137   public void testWritableField() throws Exception {
 138     try {
 139       doTest("B", "A", 0);
 140       fail("conflict expected");
 141     }
 142     catch (BaseRefactoringProcessor.ConflictsInTestsException e) {
 143       assertEquals("Field <b><code>B.ONE</code></b> has write access but is moved to an interface", e.getMessage());
 144     }
 145   }
 146
 147   public void testFinalFieldWithInitializer() throws Exception {
 148     try {
 149       doTest("B", "A", 0);
 150       fail("conflict expected");
 151     }
 152     catch (BaseRefactoringProcessor.ConflictsInTestsException e) {
 153       assertEquals("final variable initializer won't be available after move.", e.getMessage());
 154     }
 155   }
 156
 157   public void testInnerToInterface() throws Exception {
 158     doTest("A", "B", 0);
 159   }
 160
 161   public void testStaticToInterface() throws Exception {
 162     final LanguageLevelProjectExtension levelProjectExtension = LanguageLevelProjectExtension.getInstance(getProject());
 163     final LanguageLevel level = levelProjectExtension.getLanguageLevel();
 164     try {
 165       levelProjectExtension.setLanguageLevel(LanguageLevel.JDK_1_8);
 166       doTest("A", "B", 0);
 167     }
 168     finally {
 169       levelProjectExtension.setLanguageLevel(level);
 170     }
 171   }
 172
 173   public void testEscalateVisibility1() throws Exception {
 174     doTest("A", "B", true, VisibilityUtil.ESCALATE_VISIBILITY, 0);
 175   }
 176
 177   public void testStringConstantInSwitchLabelExpression() throws Exception {
 178     doTest("A", "B", true, VisibilityUtil.ESCALATE_VISIBILITY, 0);
 179   }
 180
 181   public void testMultipleWithDependencies() throws Exception {
 182     doTest("A", "B", true, VisibilityUtil.ESCALATE_VISIBILITY, 0, 1);
 183   }
 184
 185   public void testMultipleWithDependencies1() throws Exception {
 186     doTest("A", "B", true, VisibilityUtil.ESCALATE_VISIBILITY, 0, 1);
 187   }
 188
 189   public void testFromNestedToOuter() throws Exception {
 190     doTest("Outer.Inner", "Outer", true, VisibilityUtil.ESCALATE_VISIBILITY, 0);
 191   }
 192
 193   public void testFromNestedToOuterMethodRef() throws Exception {
 194     final LanguageLevelProjectExtension projectExtension = LanguageLevelProjectExtension.getInstance(getProject());
 195     final LanguageLevel oldLevel = projectExtension.getLanguageLevel();
 196     try {
 197       projectExtension.setLanguageLevel(LanguageLevel.HIGHEST);
 198       doTest("Outer.Inner", "Outer", true, VisibilityUtil.ESCALATE_VISIBILITY, 0);
 199     }
 200     finally {
 201       projectExtension.setLanguageLevel(oldLevel);
 202     }
 203   }
 204
 205   @NotNull
 206   @Override
 207   protected String getTestRoot() {
 208     return "/refactoring/moveMembers/";
 209   }
 210
 211   private void doTest(final String sourceClassName, final String targetClassName, final int... memberIndices) throws Exception {
 212     doTest(sourceClassName, targetClassName, true, memberIndices);
 213   }
 214
 215   private void doTest(final String sourceClassName,
 216                       final String targetClassName,
 217                       final boolean lowercaseFirstLetter,
 218                       final int... memberIndices) throws Exception {
 219     doTest(sourceClassName, targetClassName, lowercaseFirstLetter, null, memberIndices);
 220   }
 221
 222   private void doTest(final String sourceClassName,
 223                       final String targetClassName,
 224                       final boolean lowercaseFirstLetter,
 225                       final String defaultVisibility,
 226                       final int... memberIndices)
 227     throws Exception {
 228     doTest((rootDir, rootAfter) -> {
 229       MoveMembersTest.this.performAction(sourceClassName, targetClassName, memberIndices, defaultVisibility);
 230     }, lowercaseFirstLetter);
 231   }
 232
 233   private void performAction(String sourceClassName, String targetClassName, int[] memberIndices, final String visibility) throws Exception {
 234     PsiClass sourceClass = myJavaFacade.findClass(sourceClassName, ProjectScope.getProjectScope(myProject));
 235     assertNotNull("Class " + sourceClassName + " not found", sourceClass);
 236     PsiClass targetClass = myJavaFacade.findClass(targetClassName, ProjectScope.getProjectScope(myProject));
 237     assertNotNull("Class " + targetClassName + " not found", targetClass);
 238
 239     PsiElement[] children = sourceClass.getChildren();
 240     ArrayList<PsiMember> members = new ArrayList<>();
 241     for (PsiElement child : children) {
 242       if (child instanceof PsiMember) {
 243         members.add(((PsiMember) child));
 244       }
 245     }
 246
 247     LinkedHashSet<PsiMember> memberSet = new LinkedHashSet<>();
 248     for (int index : memberIndices) {
 249       PsiMember member = members.get(index);
 250       assertTrue(member.hasModifierProperty(PsiModifier.STATIC));
 251       memberSet.add(member);
 252     }
 253
 254     MockMoveMembersOptions options = new MockMoveMembersOptions(targetClass.getQualifiedName(), memberSet);
 255     options.setMemberVisibility(visibility);
 256     new MoveMembersProcessor(myProject, null, options).run();
 257     FileDocumentManager.getInstance().saveAllDocuments();
 258   }
 259 }