diff --git a/java/java-impl/src/META-INF/JavaPlugin.xml b/java/java-impl/src/META-INF/JavaPlugin.xml index 0a174ac9c5cb..7186137a4d8a 100644 --- a/java/java-impl/src/META-INF/JavaPlugin.xml +++ b/java/java-impl/src/META-INF/JavaPlugin.xml @@ -1251,6 +1251,7 @@ + diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/AbstractExpectedTypeSkipper.java b/java/java-impl/src/com/intellij/codeInsight/completion/AbstractExpectedTypeSkipper.java index 63e1a53ff0b4..000c39777ff7 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/AbstractExpectedTypeSkipper.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/AbstractExpectedTypeSkipper.java @@ -18,6 +18,7 @@ package com.intellij.codeInsight.completion; import com.intellij.codeInsight.ExpectedTypeInfo; import com.intellij.codeInsight.generation.OverrideImplementExploreUtil; import com.intellij.codeInsight.lookup.LookupElement; +import com.intellij.openapi.project.DumbService; import com.intellij.psi.*; import com.intellij.psi.statistics.StatisticsManager; import com.intellij.psi.util.PsiTreeUtil; @@ -46,6 +47,7 @@ public class AbstractExpectedTypeSkipper extends CompletionPreselectSkipper { private static Result getSkippingStatus(final LookupElement item, final CompletionLocation location) { if (location.getCompletionType() != CompletionType.SMART && !hasEmptyPrefix(location)) return Result.ACCEPT; + if (DumbService.getInstance(location.getProject()).isDumb()) return Result.ACCEPT; CompletionParameters parameters = location.getCompletionParameters(); PsiExpression expression = PsiTreeUtil.getParentOfType(parameters.getPosition(), PsiExpression.class); diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/ConstructorInsertHandler.java b/java/java-impl/src/com/intellij/codeInsight/completion/ConstructorInsertHandler.java index c2df516d77b3..ac8b60dbb06d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/ConstructorInsertHandler.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/ConstructorInsertHandler.java @@ -27,6 +27,7 @@ import com.intellij.openapi.editor.Document; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.editor.RangeMarker; import com.intellij.openapi.editor.ScrollType; +import com.intellij.openapi.project.DumbService; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleManager; @@ -309,6 +310,7 @@ public class ConstructorInsertHandler implements InsertHandler { TemplateManager.getInstance(project).finishTemplate(editor); + if (DumbService.getInstance(project).isDumb()) return; PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument()); final PsiAnonymousClass diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java index 7b48957cb470..a7653d78d08d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaGenerateMemberCompletionContributor.java @@ -9,6 +9,7 @@ import com.intellij.codeInspection.ex.GlobalInspectionContextBase; import com.intellij.icons.AllIcons; import com.intellij.openapi.application.AccessToken; import com.intellij.openapi.command.CommandProcessor; +import com.intellij.openapi.project.DumbService; import com.intellij.openapi.util.Iconable; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.TextRange; @@ -45,8 +46,11 @@ public class JavaGenerateMemberCompletionContributor { if (parameters.getCompletionType() != CompletionType.BASIC && parameters.getCompletionType() != CompletionType.SMART) { return; } - PsiElement position = parameters.getPosition(); + if (DumbService.getInstance(position.getProject()).isDumb()) { + return; + } + if (psiElement(PsiIdentifier.class).withParents(PsiJavaCodeReferenceElement.class, PsiTypeElement.class, PsiClass.class). andNot(JavaKeywordCompletion.AFTER_DOT).accepts(position)) { PsiElement prevLeaf = PsiTreeUtil.prevVisibleLeaf(position); diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaKeywordCompletion.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaKeywordCompletion.java index 3e9512540104..41f6fd5dbbfb 100644 --- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaKeywordCompletion.java +++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaKeywordCompletion.java @@ -640,9 +640,13 @@ public class JavaKeywordCompletion { } if (position instanceof PsiIdentifier && position.getParent() instanceof PsiLocalVariable) { - PsiType type = ((PsiLocalVariable)position.getParent()).getType(); - if (type instanceof PsiClassType && ((PsiClassType)type).resolve() == null) { - return true; + PsiType type = ((PsiLocalVariable) position.getParent()).getType(); + if (type instanceof PsiClassType && ((PsiClassType) type).resolve() == null) { + PsiElement grandParent = position.getParent().getParent(); + if (!(grandParent instanceof PsiDeclarationStatement) || !(grandParent.getParent() instanceof PsiForStatement) || + ((PsiForStatement) grandParent.getParent()).getInitialization() != grandParent) { + return true; + } } } diff --git a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java index 09606ca1462b..807a626d3b34 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java @@ -842,8 +842,14 @@ public class TypeConversionUtil { } final PsiClassType.ClassResolveResult leftResult = PsiUtil.resolveGenericsClassInType(left); final PsiClassType.ClassResolveResult rightResult = PsiUtil.resolveGenericsClassInType(right); - if (leftResult.getElement() == null || rightResult.getElement() == null) { - if (leftResult.getElement() != rightResult.getElement()) return false; + PsiClass leftResultElement = leftResult.getElement(); + PsiClass rightResultElement = rightResult.getElement(); + if (leftResultElement == null || rightResultElement == null) { + if (leftResultElement == null && rightResultElement != null && + left instanceof PsiClassType && left.equalsToText(JAVA_LANG_OBJECT)) { + return true; + } + if (leftResultElement != rightResultElement) return false; // let's suppose 2 unknown classes, which could be the same to be the same String lText = left.getPresentableText(); String rText = right.getPresentableText(); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFinderImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFinderImpl.java index b54e2f850ea0..ffc9f58f0ce8 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFinderImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiElementFinderImpl.java @@ -3,7 +3,7 @@ package com.intellij.psi.impl; import com.intellij.openapi.application.ReadActionProcessor; import com.intellij.openapi.project.DumbAware; -import com.intellij.openapi.project.DumbService; +import com.intellij.openapi.project.DumbUtil; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.FileIndexFacade; import com.intellij.openapi.roots.PackageIndex; @@ -43,7 +43,7 @@ public final class PsiElementFinderImpl extends PsiElementFinder implements Dumb @Override public PsiClass findClass(@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) { - if (DumbService.getInstance(myProject).isDumb()) { + if (!DumbUtil.getInstance(myProject).mayUseIndices()) { return null; } return myFileManager.findClass(qualifiedName, scope); @@ -51,7 +51,7 @@ public final class PsiElementFinderImpl extends PsiElementFinder implements Dumb @Override public PsiClass @NotNull [] findClasses(@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) { - if (DumbService.getInstance(myProject).isDumb()) { + if (!DumbUtil.getInstance(myProject).mayUseIndices()) { return PsiClass.EMPTY_ARRAY; } return myFileManager.findClasses(qualifiedName, scope); diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsMethodImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsMethodImpl.java index 8b50a833a171..ed1ec237bda9 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsMethodImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/compiled/ClsMethodImpl.java @@ -4,8 +4,10 @@ package com.intellij.psi.impl.compiled; import com.intellij.navigation.ItemPresentation; import com.intellij.navigation.ItemPresentationProviders; import com.intellij.openapi.project.IndexNotReadyException; -import com.intellij.openapi.roots.FileIndexFacade; -import com.intellij.openapi.util.*; +import com.intellij.openapi.util.AtomicNotNullLazyValue; +import com.intellij.openapi.util.NotNullLazyValue; +import com.intellij.openapi.util.NullableLazyValue; +import com.intellij.openapi.util.VolatileNullableLazyValue; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.impl.ElementPresentationUtil; @@ -20,7 +22,10 @@ import com.intellij.psi.impl.source.tree.TreeElement; import com.intellij.psi.scope.PsiScopeProcessor; import com.intellij.psi.scope.util.PsiScopesUtil; import com.intellij.psi.search.SearchScope; -import com.intellij.psi.util.*; +import com.intellij.psi.util.CachedValuesManager; +import com.intellij.psi.util.MethodSignature; +import com.intellij.psi.util.MethodSignatureBackedByPsiMethod; +import com.intellij.psi.util.MethodSignatureUtil; import com.intellij.ui.IconManager; import com.intellij.ui.icons.RowIcon; import com.intellij.util.PlatformIcons; @@ -260,11 +265,7 @@ public class ClsMethodImpl extends ClsMemberImpl implements PsiAn @Nullable public PsiMethod getSourceMirrorMethod() { - return CachedValuesManager.getCachedValue(this, () -> { - PsiFile file = getContainingFile(); - ModificationTracker tracker = FileIndexFacade.getInstance(getProject()).getRootModificationTracker(); - return CachedValueProvider.Result.create(calcSourceMirrorMethod(), file, file.getNavigationElement(), tracker); - }); + return CachedValuesManager.getProjectPsiDependentCache(this, __ -> calcSourceMirrorMethod()); } @Nullable diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java index 912ec2b1a859..83e8f0a34db9 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/file/PsiPackageImpl.java @@ -169,8 +169,8 @@ public class PsiPackageImpl extends PsiPackageBase implements PsiPackage, Querya private PsiClass @NotNull [] getCachedClassesByName(@NotNull String name, GlobalSearchScope scope) { DumbService dumbService = DumbService.getInstance(getProject()); - if (dumbService.isDumb()) { - return dumbService.isAlternativeResolveEnabled() ? getCachedClassesInDumbMode(name, scope) : PsiClass.EMPTY_ARRAY; + if (dumbService.isDumb() && dumbService.isAlternativeResolveEnabled()) { + return getCachedClassesInDumbMode(name, scope); } if (ModelBranchImpl.hasBranchedFilesInScope(scope)) { diff --git a/java/java-tests/testData/codeInsight/completion/keywords/newInNegation_after.java b/java/java-tests/testData/codeInsight/completion/keywords/newInNegation_after.java new file mode 100644 index 000000000000..95f7a39fe15a --- /dev/null +++ b/java/java-tests/testData/codeInsight/completion/keywords/newInNegation_after.java @@ -0,0 +1,6 @@ +class Foo { + + Object test() { + return !new + } +} diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/AtomicFieldUpdaterCompletionTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/AtomicFieldUpdaterCompletionTest.kt index 2b83754606e8..6b27f4d0f59e 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/AtomicFieldUpdaterCompletionTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/AtomicFieldUpdaterCompletionTest.kt @@ -2,7 +2,9 @@ package com.intellij.java.codeInsight.completion import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase +import com.intellij.testFramework.NeedsIndicesState +@NeedsIndicesState.FullIndices class AtomicFieldUpdaterCompletionTest : LightFixtureCompletionTestCase() { override fun setUp() { super.setUp() diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ClassNameCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ClassNameCompletionTest.java index 7939ca6bd4fe..f204faeb2911 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ClassNameCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ClassNameCompletionTest.java @@ -14,6 +14,7 @@ import com.intellij.openapi.roots.LanguageLevelProjectExtension; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.PsiClass; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.testFramework.TestDataPath; import java.io.IOException; @@ -32,6 +33,7 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { return JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/completion/className/"; } + @NeedsIndicesState.FullIndices public void testImportAfterNew() { createClass("package pack; public class AAClass {}"); createClass("package pack; public class WithInnerAClass{\n" + @@ -60,11 +62,12 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { myFixture.getFile().findElementAt(myFixture.getEditor().getCaretModel().getOffset()) ); - assertEquals(doc, - "Candidates for new Time() are:
  Time()
 " + - " Time(long time)
"); + assertEquals("Candidates for new Time() are:
  Time()" + + "
  Time(long time)
", + doc); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testTypeParametersTemplate() { createClass("package pack; public interface Foo {void foo(T t};"); @@ -91,6 +94,7 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { } private void createClass(String text) { + //noinspection LanguageMismatch myFixture.addClass(text); } @@ -111,6 +115,7 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { "}"); } + @NeedsIndicesState.FullIndices public void testAfterNewThrowable2() { addClassesForAfterNewThrowable(); String path = "/afterNewThrowable"; @@ -126,6 +131,7 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { public void testBracesAfterNew() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode not supported for property files") public void testInPropertiesFile() { myFixture.configureByText("a.properties", "abc = StrinBui"); complete(); @@ -144,6 +150,7 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { assertNull(myItems); } + @NeedsIndicesState.FullIndices public void testReplaceReferenceExpressionWithTypeElement() { createClass("package foo.bar; public class ABCDEF {}"); doTest(); @@ -194,6 +201,7 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/implements3-result.java"); } + @NeedsIndicesState.FullIndices public void testAnnotationFiltering() { createClass("@interface MyObjectType {}"); @@ -276,16 +284,20 @@ public class ClassNameCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/varType-result.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testExtraSpace() { doJavaTest('\n'); } public void testAnnotation() { doJavaTest('\n'); } + @NeedsIndicesState.StandardLibraryIndices public void testInStaticImport() { doJavaTest('\n'); } + @NeedsIndicesState.StandardLibraryIndices public void testInCommentWithPackagePrefix() { doJavaTest('\n'); } public void testNestedAnonymousTab() { doJavaTest('\t');} + @NeedsIndicesState.FullIndices public void testClassStartsWithUnderscore() { myFixture.addClass("package foo; public class _SomeClass {}"); doJavaTest('\n'); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/CompletionStyleTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/CompletionStyleTest.java index d3d5ec2e2754..5062d7880fb7 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/CompletionStyleTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/CompletionStyleTest.java @@ -14,6 +14,7 @@ import com.intellij.openapi.roots.LanguageLevelProjectExtension; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; import com.intellij.testFramework.LightJavaCodeInsightTestCase; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.testFramework.TestDataPath; import org.jetbrains.annotations.NotNull; @@ -32,6 +33,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { return JavaTestUtil.getJavaTestDataPath(); } + @NeedsIndicesState.FullIndices public void testGenericParametersReplace() { final String path = BASE_PATH; @@ -91,6 +93,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after3.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodsParametersStyle2() { final String path = BASE_PATH; @@ -108,6 +111,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after6.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testLocalVariablePreselect() { configureByFile(BASE_PATH + "/before5.java"); @@ -115,6 +119,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { assertEquals("xxxx", getSelected().getLookupString()); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodCompletionInsideInlineTags() { final String path = BASE_PATH; @@ -151,6 +156,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after10.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testCaretPositionAfterCompletion1() { final String path = BASE_PATH; @@ -160,6 +166,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after11.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testCaretPositionAfterCompletion2() { final String path = BASE_PATH; @@ -169,6 +176,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after12.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testParensReuse() { final String path = BASE_PATH; @@ -188,6 +196,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after22.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodReplacementReuseParens1() { final String path = BASE_PATH; @@ -197,6 +206,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after15.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodReplacementReuseParens2() { final String path = BASE_PATH; @@ -206,6 +216,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after16.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodReplacementReuseParens3() { final String path = BASE_PATH; @@ -233,6 +244,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { checkResultByFile(path + "/after31.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodParensStyle2() { final String path = BASE_PATH; CommonCodeStyleSettings styleSettings = getCodeStyleSettings(); @@ -249,6 +261,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { } + @NeedsIndicesState.StandardLibraryIndices public void testMethodParensStyle3() { final String path = BASE_PATH; CommonCodeStyleSettings styleSettings = getCodeStyleSettings(); @@ -336,6 +349,7 @@ public class CompletionStyleTest extends LightJavaCodeInsightTestCase { return LookupManager.getInstance(getProject()).getActiveLookup().getCurrentItem(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testAfterNew15() { final LanguageLevelProjectExtension ll = LanguageLevelProjectExtension.getInstance(getProject()); final LanguageLevel old = ll.getLanguageLevel(); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/DotCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/DotCompletionTest.java index cca40c45672f..24bc25349de9 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/DotCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/DotCompletionTest.java @@ -3,6 +3,7 @@ package com.intellij.java.codeInsight.completion; import com.intellij.JavaTestUtil; import com.intellij.codeInsight.completion.LightCompletionTestCase; +import com.intellij.testFramework.NeedsIndicesState; import org.jetbrains.annotations.NotNull; public class DotCompletionTest extends LightCompletionTestCase { @@ -42,6 +43,7 @@ public class DotCompletionTest extends LightCompletionTestCase { assertContainsItems("util", "lang"); } + @NeedsIndicesState.StandardLibraryIndices public void testArrayElement() { configureByFile("Dot6.java"); assertContainsItems("toString", "substring"); @@ -79,6 +81,7 @@ public class DotCompletionTest extends LightCompletionTestCase { assertNotContainItems("foo1"); } + @NeedsIndicesState.StandardLibraryIndices public void testMultiCatch() { configureByFile("MultiCatch.java"); assertContainsItems("i", "addSuppressed", "getMessage", "printStackTrace"); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/FragmentCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/FragmentCompletionTest.groovy index e66a6b5fd361..cf517ef19987 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/FragmentCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/FragmentCompletionTest.groovy @@ -21,6 +21,7 @@ import com.intellij.codeInsight.completion.JavaCompletionUtil import com.intellij.ide.highlighter.JavaFileType import com.intellij.lang.java.JavaLanguage import com.intellij.psi.* +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase import com.intellij.util.PairFunction import groovy.transform.CompileStatic @@ -90,6 +91,7 @@ class FragmentCompletionTest extends LightJavaCodeInsightFixtureTestCase { assert myFixture.lookupElementStrings[0..1] == ['boolean', 'byte'] } + @NeedsIndicesState.StandardLibraryIndices void testQualifierCastingInExpressionCodeFragment() throws Throwable { final ctxText = "class Bar {{ Object o; o=null }}" final ctxFile = createLightFile(JavaFileType.INSTANCE, ctxText) @@ -102,6 +104,7 @@ class FragmentCompletionTest extends LightJavaCodeInsightFixtureTestCase { myFixture.checkResult("o instanceof String && ((String) o).substring()") } + @NeedsIndicesState.StandardLibraryIndices void testNoGenericQualifierCastingWithRuntimeType() throws Throwable { final ctxText = "import java.util.*; class Bar {{ Map map = new HashMap(); map=null; }}" final ctxFile = createLightFile(JavaFileType.INSTANCE, ctxText) @@ -142,6 +145,7 @@ class FragmentCompletionTest extends LightJavaCodeInsightFixtureTestCase { assert !myFixture.lookupElementStrings.contains('class') } + @NeedsIndicesState.StandardLibraryIndices void "test annotation context"() { def ctxFile = myFixture.addClass("class Class { void foo(int context) { @Anno int a; } }").containingFile def context = ctxFile.findElementAt(ctxFile.text.indexOf('Anno')) @@ -151,6 +155,7 @@ class FragmentCompletionTest extends LightJavaCodeInsightFixtureTestCase { assert myFixture.lookupElementStrings.contains('context') } + @NeedsIndicesState.FullIndices void "test proximity ordering in scratch-like file"() { def barField = myFixture.addClass('package bar; public class Field {}') def fooField = myFixture.addClass('package foo; public class Field {}') @@ -163,6 +168,7 @@ class FragmentCompletionTest extends LightJavaCodeInsightFixtureTestCase { assert barField == items[1].object } + @NeedsIndicesState.StandardLibraryIndices void "test package default class in code fragment"() { myFixture.addClass "class ABCD {}" PsiJavaCodeReferenceCodeFragment fragment = @@ -173,6 +179,7 @@ class FragmentCompletionTest extends LightJavaCodeInsightFixtureTestCase { assert myFixture.lookupElements.find { (it.lookupString == "ABCD") } != null } + @NeedsIndicesState.FullIndices void "test qualified class in code fragment"() { myFixture.addClass "package foo; public class Foo1 {}" PsiJavaCodeReferenceCodeFragment fragment = diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/GlobalMemberNameCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/GlobalMemberNameCompletionTest.groovy index 655d2d90499d..0f41790f5b28 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/GlobalMemberNameCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/GlobalMemberNameCompletionTest.groovy @@ -23,6 +23,7 @@ import com.intellij.codeInsight.lookup.LookupElementPresentation import com.intellij.lang.java.JavaLanguage import com.intellij.openapi.util.ClassConditionKey import com.intellij.psi.codeStyle.CodeStyleSettingsManager +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase import groovy.transform.CompileStatic @@ -32,6 +33,7 @@ import groovy.transform.CompileStatic @CompileStatic class GlobalMemberNameCompletionTest extends LightJavaCodeInsightFixtureTestCase { + @NeedsIndicesState.FullIndices void testMethodName() throws Exception { myFixture.addClass(""" package foo; @@ -47,6 +49,7 @@ public class Foo { class Bar {{ abcmethod() }}""" } + @NeedsIndicesState.FullIndices void testFieldName() throws Exception { myFixture.addClass(""" package foo; @@ -62,6 +65,7 @@ public class Foo { class Bar {{ abcfield }}""" } + @NeedsIndicesState.FullIndices void testFieldNameQualified() throws Exception { myFixture.addClass(""" package foo; @@ -77,6 +81,7 @@ public class Foo { class Bar {{ Foo.abcfield }}""" } + @NeedsIndicesState.FullIndices void testFieldNamePresentation() { myFixture.addClass(""" package foo; @@ -98,6 +103,7 @@ public class Foo { myFixture.complete(CompletionType.BASIC, 2) } + @NeedsIndicesState.FullIndices void testQualifiedMethodName() throws Exception { myFixture.addClass(""" package foo; @@ -112,6 +118,7 @@ public class Foo { class Bar {{ Foo.abcmethod() }}""" } + @NeedsIndicesState.FullIndices void testIfThereAreAlreadyStaticImportsWithThatClass() throws Exception { myFixture.addClass(""" package foo; @@ -132,7 +139,7 @@ import static foo.Foo.anotherMethod; class Bar {{ abcmethod(); anotherMethod() }}""" } - + @NeedsIndicesState.FullIndices void testExcludeClassFromCompletion() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -152,6 +159,7 @@ class Bar {{ abcmethod(); anotherMethod() }}""" class Bar {{ abcmethod() }}""" } + @NeedsIndicesState.FullIndices void testExcludeMethodFromCompletion() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -167,6 +175,7 @@ class Bar {{ abcmethod() }}""" class Bar {{ abcmethod1() }}""" } + @NeedsIndicesState.FullIndices void testMergeOverloads() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -213,6 +222,7 @@ class A { ''' } + @NeedsIndicesState.FullIndices void "test static import before an identifier"() { myFixture.addClass ''' package test.t1; @@ -279,6 +289,7 @@ class Foo { myFixture.checkResult text } + @NeedsIndicesState.FullIndices void "test no global reformatting"() { CodeStyleSettingsManager.getSettings(project).getCommonSettings(JavaLanguage.INSTANCE).ALIGN_MULTILINE_BINARY_OPERATION = true diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavyCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavyCompletionTest.groovy index 2c3a42f3eb79..5c62765ba5f3 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavyCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavyCompletionTest.groovy @@ -25,9 +25,12 @@ import com.intellij.psi.statistics.StatisticsManager import com.intellij.psi.statistics.impl.StatisticsManagerImpl import com.intellij.psi.util.PsiTreeUtil import com.intellij.testFramework.IdeaTestUtil +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.PsiTestUtil import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase import com.intellij.ui.JBColor +import com.intellij.util.indexing.DumbModeAccessType +import com.intellij.util.indexing.FileBasedIndex import groovy.transform.CompileStatic import org.jetbrains.annotations.NotNull /** @@ -56,6 +59,7 @@ class HeavyCompletionTest extends JavaCodeInsightFixtureTestCase { assertTrue(JavaPsiFacade.getInstance(getProject()).findPackage("foo.bar.goo").isValid()) } + @NeedsIndicesState.FullIndices void testPreferTestCases() throws Throwable { myFixture.configureByFile("/codeInsight/completion/normal/" + getTestName(false) + ".java") ApplicationManager.application.runWriteAction { @@ -76,6 +80,7 @@ class HeavyCompletionTest extends JavaCodeInsightFixtureTestCase { myFixture.assertPreferredCompletionItems(0, "SomeTestCase", "SomeAnchor", "SomeTestec") } + @NeedsIndicesState.FullIndices void testAllClassesWhenNothingIsFound() throws Throwable { myFixture.addClass("package foo.bar; public class AxBxCxDxEx {}") @@ -85,6 +90,7 @@ class HeavyCompletionTest extends JavaCodeInsightFixtureTestCase { myFixture.checkResultByFile("/codeInsight/completion/normal/" + getTestName(false) + "_after.java") } + @NeedsIndicesState.FullIndices void testAllClassesOnSecondBasicCompletion() throws Throwable { myFixture.addClass("package foo.bar; public class AxBxCxDxEx {}") @@ -116,6 +122,7 @@ class HeavyCompletionTest extends JavaCodeInsightFixtureTestCase { assert myFixture.completeBasic() == null } + @NeedsIndicesState.FullIndices void testQualifyInaccessibleClassName() throws Exception { PsiTestUtil.addModule(getProject(), StdModuleTypes.JAVA, "second", myFixture.getTempDirFixture().findOrCreateDir("second")) myFixture.addFileToProject("second/foo/bar/AxBxCxDxEx.java", "package foo.bar; class AxBxCxDxEx {}") @@ -125,11 +132,15 @@ class HeavyCompletionTest extends JavaCodeInsightFixtureTestCase { myFixture.checkResult("class Main { foo.bar.AxBxCxDxEx }") } + @NeedsIndicesState.StandardLibraryIndices void testPreferOwnMethods() { def nanoUrls = IntelliJProjectConfiguration.getProjectLibraryClassesRootUrls("NanoXML") ModuleRootModificationUtil.addModuleLibrary(module, 'nano1', nanoUrls, []) - assert JavaPsiFacade.getInstance(project).findClass('net.n3.nanoxml.StdXMLParser', GlobalSearchScope.allScope(project)) + def finalProject = project + FileBasedIndex.getInstance().ignoreDumbMode(DumbModeAccessType.RELIABLE_DATA_ONLY, { -> + assert JavaPsiFacade.getInstance(finalProject).findClass('net.n3.nanoxml.StdXMLParser', GlobalSearchScope.allScope(finalProject)) + }) myFixture.configureByText "a.java", """ public class Test { @@ -168,6 +179,7 @@ public class Test { assert oldCount == tracker.modificationCount } + @NeedsIndicesState.FullIndices void testForbiddenApiVariants() { IdeaTestUtil.setModuleLanguageLevel(module, LanguageLevel.JDK_1_4) myFixture.addClass("""\ @@ -197,6 +209,7 @@ public class SocketChannel { assert p.itemTextForeground == JBColor.foreground() } + @NeedsIndicesState.StandardLibraryIndices void "test seemingly scrambled subclass"() { PsiTestUtil.addLibrary(module, JavaTestUtil.getJavaTestDataPath() + "/codeInsight/completion/normal/seemsScrambled.jar") myFixture.configureByText 'a.java', '''import test.Books; @@ -211,6 +224,7 @@ class Foo {{ Books.Test.v1 }} } + @NeedsIndicesState.FullIndices void "test different jdks in different modules"() { (StatisticsManager.instance as StatisticsManagerImpl).enableStatistics(myFixture.testRootDisposable) diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavySmartTypeCompletion15Test.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavySmartTypeCompletion15Test.groovy index 1dad406b1006..5fc3b52f22b9 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavySmartTypeCompletion15Test.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/HeavySmartTypeCompletion15Test.groovy @@ -6,6 +6,7 @@ import com.intellij.codeInsight.completion.CompletionType import com.intellij.openapi.module.Module import com.intellij.openapi.module.StdModuleTypes import com.intellij.openapi.roots.ModuleRootModificationUtil +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.PsiTestUtil import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase import groovy.transform.CompileStatic @@ -19,6 +20,7 @@ class HeavySmartTypeCompletion15Test extends JavaCodeInsightFixtureTestCase { return JavaTestUtil.getJavaTestDataPath() } + @NeedsIndicesState.FullIndices(reason = "ClassLiteralGetter provides option, but it's filtered out in TypeConversionUtil.isAssignable(com.intellij.psi.PsiType, com.intellij.psi.PsiType)") void testGetInstance() throws Throwable { myFixture.configureFromExistingVirtualFile( myFixture.copyFileToProject(BASE_PATH + "/foo/" + getTestName(false) + ".java", "foo/" + getTestName(false) + ".java")) @@ -27,6 +29,7 @@ class HeavySmartTypeCompletion15Test extends JavaCodeInsightFixtureTestCase { myFixture.checkResultByFile(BASE_PATH + "/foo/" + getTestName(false) + "-out.java") } + @NeedsIndicesState.FullIndices void testProtectedAnonymousConstructor() throws Throwable { myFixture.addClass("package pkg;" + "public class Foo {" + @@ -39,6 +42,7 @@ class HeavySmartTypeCompletion15Test extends JavaCodeInsightFixtureTestCase { doTest() } + @NeedsIndicesState.FullIndices void testProtectedAnonymousConstructor2() throws Throwable { myFixture.addClass("package pkg;" + "public class Foo {" + @@ -51,6 +55,7 @@ class HeavySmartTypeCompletion15Test extends JavaCodeInsightFixtureTestCase { doTest() } + @NeedsIndicesState.FullIndices void testUnlockDocument() throws Throwable { myFixture.addClass("package pkg; public class Bar {}") myFixture.addClass("package pkg; public class Foo {" + @@ -74,6 +79,7 @@ class HeavySmartTypeCompletion15Test extends JavaCodeInsightFixtureTestCase { myFixture.complete(CompletionType.SMART) } + @NeedsIndicesState.FullIndices void testClassLiteralShouldInsertImport() throws Throwable { myFixture.addClass("package bar; public class Intf {}") myFixture.addClass("package foo; public class Bar extends bar.Intf {}") @@ -94,7 +100,12 @@ class HeavySmartTypeCompletion15Test extends JavaCodeInsightFixtureTestCase { myFixture.addFileToProject('b/bar/Bar.java', 'package bar; public class Bar { public static void accept(foo.Foo i) {} }') configure() + if (indexingMode == IndexingMode.DUMB_EMPTY_INDEX || indexingMode == IndexingMode.DUMB_RUNTIME_ONLY_INDEX) { + assertNull(myFixture.getLookup()) + return + } myFixture.type('\n') + checkResult() } } \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaCompletionTestSuite.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaCompletionTestSuite.java new file mode 100644 index 000000000000..e2e7897a65c7 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaCompletionTestSuite.java @@ -0,0 +1,117 @@ +// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.java.codeInsight.completion; + +import com.intellij.TestAll; +import com.intellij.TestCaseLoader; +import com.intellij.codeInsight.completion.JavaCompletionAutoPopupTestCase; +import com.intellij.testFramework.NeedsIndicesState; +import com.intellij.testFramework.SkipSlowTestLocally; +import com.intellij.testFramework.TestIndexingModeSupporter; +import junit.framework.Test; +import junit.framework.TestSuite; +import org.jetbrains.annotations.NotNull; + +import java.lang.reflect.Method; + +@SkipSlowTestLocally +public class JavaCompletionTestSuite extends TestSuite { + + private static final TestIndexingModeSupporter.IndexingModeTestHandler FULL_INDEX_TRANSFORMATION = new FullIndexSuite(); + + private static class FullIndexSuite extends TestIndexingModeSupporter.IndexingModeTestHandler { + private FullIndexSuite() { + super("Full index", "Full index: "); + } + + @Override + public boolean shouldIgnore(@NotNull Class aClass) { + return JavaCompletionAutoPopupTestCase.class.isAssignableFrom(aClass) || + CompletionHintsTest.class == aClass || + aClass.isAnnotationPresent(NeedsIndicesState.SmartMode.class); + } + + @Override + public boolean shouldIgnore(@NotNull Method method, + @NotNull Class aClass) { + return method.isAnnotationPresent(NeedsIndicesState.SmartMode.class); + } + + @Override + public TestIndexingModeSupporter.@NotNull IndexingMode getIndexingMode() { + return TestIndexingModeSupporter.IndexingMode.DUMB_FULL_INDEX; + } + } + + private static final TestIndexingModeSupporter.IndexingModeTestHandler RUNTIME_ONLY_INDEX_TRANSFORMATION = new RuntimeOnlyIndexSuite(); + + private static class RuntimeOnlyIndexSuite extends TestIndexingModeSupporter.IndexingModeTestHandler { + + private RuntimeOnlyIndexSuite() { + super("RuntimeOnlyIndex", "Runtime only index: "); + } + + @Override + public boolean shouldIgnore(@NotNull Class aClass) { + return FULL_INDEX_TRANSFORMATION.shouldIgnore(aClass) || aClass.isAnnotationPresent(NeedsIndicesState.FullIndices.class); + } + + @Override + public boolean shouldIgnore(@NotNull Method method, + @NotNull Class aClass) { + return FULL_INDEX_TRANSFORMATION.shouldIgnore(method, aClass) || method.isAnnotationPresent(NeedsIndicesState.FullIndices.class); + } + + @Override + public TestIndexingModeSupporter.@NotNull IndexingMode getIndexingMode() { + return TestIndexingModeSupporter.IndexingMode.DUMB_RUNTIME_ONLY_INDEX; + } + } + + private static final TestIndexingModeSupporter.IndexingModeTestHandler EMPTY_INDEX_TRANSFORMATION = new EmptyIndexSuite(); + + private static class EmptyIndexSuite extends TestIndexingModeSupporter.IndexingModeTestHandler { + + private EmptyIndexSuite() { + super("EmptyIndex", "Empty index: "); + } + + @Override + public boolean shouldIgnore(@NotNull Class aClass) { + return RUNTIME_ONLY_INDEX_TRANSFORMATION.shouldIgnore(aClass) || aClass.isAnnotationPresent(NeedsIndicesState.StandardLibraryIndices.class); + } + + @Override + public boolean shouldIgnore(@NotNull Method method, @NotNull Class aClass) { + return RUNTIME_ONLY_INDEX_TRANSFORMATION.shouldIgnore(method, aClass) || method.isAnnotationPresent(NeedsIndicesState.StandardLibraryIndices.class); + } + + @Override + public TestIndexingModeSupporter.@NotNull IndexingMode getIndexingMode() { + return TestIndexingModeSupporter.IndexingMode.DUMB_EMPTY_INDEX; + } + } + + public static Test suite() { + JavaCompletionTestSuite suite = new JavaCompletionTestSuite(); + if (!"Java Dumb Completion Tests".equals(System.getProperty("teamcity.buildConfName"))) { + return suite; + } + suite.setName("Java completion tests suite"); + System.setProperty("intellij.build.test.groups", "JAVA_TESTS"); + TestCaseLoader myTestCaseLoader = new TestCaseLoader("tests/testGroups.properties"); + myTestCaseLoader.fillTestCases("", TestAll.getClassRoots()); + for (Class aClass : myTestCaseLoader.getClasses()) { + if (!aClass.getSimpleName().contains("Completion")) continue; + if (TestIndexingModeSupporter.class.isAssignableFrom(aClass)) { + //noinspection unchecked + Class testCaseClass = (Class)aClass; + TestIndexingModeSupporter.addTest(testCaseClass, FULL_INDEX_TRANSFORMATION, suite); + TestIndexingModeSupporter.addTest(testCaseClass, RUNTIME_ONLY_INDEX_TRANSFORMATION, suite); + TestIndexingModeSupporter.addTest(testCaseClass, EMPTY_INDEX_TRANSFORMATION, suite); + } else if (!JavaCompletionTestSuite.class.equals(aClass)) { + suite.addTest(warning("Unexpected class " + aClass + " in " + suite.getClass())); + } + } + return suite; + } +} diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaLangInvokeHandleCompletionTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaLangInvokeHandleCompletionTest.kt index 3a32ae788103..3fdc8cdc183a 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaLangInvokeHandleCompletionTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaLangInvokeHandleCompletionTest.kt @@ -19,11 +19,13 @@ import com.intellij.JavaTestUtil import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase import com.intellij.codeInsight.lookup.LookupElementPresentation import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase /** * @author Pavel Dolgov */ +@NeedsIndicesState.FullIndices class JavaLangInvokeHandleCompletionTest : LightFixtureCompletionTestCase() { override fun getProjectDescriptor(): LightProjectDescriptor = LightJavaCodeInsightFixtureTestCase.JAVA_9 diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionOverloadTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionOverloadTest.kt index cfa041e48e84..4401f549ca38 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionOverloadTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionOverloadTest.kt @@ -17,10 +17,12 @@ package com.intellij.java.codeInsight.completion import com.intellij.JavaTestUtil import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase +import com.intellij.testFramework.NeedsIndicesState /** * @author Pavel.Dolgov */ +@NeedsIndicesState.StandardLibraryIndices class JavaReflectionCompletionOverloadTest : LightFixtureCompletionTestCase() { override fun getBasePath() = JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/completion/reflectionOverload/" @@ -66,7 +68,7 @@ class JavaReflectionCompletionOverloadTest : LightFixtureCompletionTestCase() { configureByFile(getTestName(false) + ".java") val lookupItems = lookup.items - val texts = com.intellij.java.codeInsight.completion.lookupFirstItemsTexts(lookupItems, expected.size) + val texts = lookupFirstItemsTexts(lookupItems, expected.size) assertOrderedEquals(texts, *expected) if (index >= 0) selectItem(lookupItems[index]) myFixture.checkResultByFile(getTestName(false) + "_after.java") diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionTest.java index 0713d564e40b..63fe787e9db3 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionCompletionTest.java @@ -19,11 +19,13 @@ import com.intellij.JavaTestUtil; import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase; import com.intellij.pom.java.LanguageLevel; import com.intellij.testFramework.IdeaTestUtil; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.util.ArrayUtil; /** * @author Konstantin Bulenkov */ +@NeedsIndicesState.StandardLibraryIndices public class JavaReflectionCompletionTest extends LightFixtureCompletionTestCase { @Override @@ -51,22 +53,27 @@ public class JavaReflectionCompletionTest extends LightFixtureCompletionTestCase doTestFirst(1, "method", "method2", "method3"); } + @NeedsIndicesState.FullIndices public void testForNameDeclaredMethod() { doTest(2, "method", "method1", "method2"); } + @NeedsIndicesState.FullIndices public void testForNameMethod() { doTestFirst(1, "method", "method2", "method3"); } + @NeedsIndicesState.FullIndices public void testForNameField() { doTest(1, "num", "num2", "num3"); } + @NeedsIndicesState.FullIndices public void testForNameDeclaredField() { doTest(1, "num", "num1", "num2"); } + @NeedsIndicesState.FullIndices public void testVarargMethod() { doTest(0, "vararg", "vararg2"); } @@ -108,10 +115,12 @@ public class JavaReflectionCompletionTest extends LightFixtureCompletionTestCase doTestFirst(1, "method", "method2"); } + @NeedsIndicesState.FullIndices public void testInitChain() { doTest(1, "num", "num2"); } + @NeedsIndicesState.FullIndices public void testAssignChain() { doTest(1, "num", "num2"); } @@ -165,6 +174,7 @@ public class JavaReflectionCompletionTest extends LightFixtureCompletionTestCase doTest(-1); } + @NeedsIndicesState.FullIndices public void testClassForNamePackages() { myFixture.addClass("package foo.bar.one; public class FirstClass {}"); myFixture.addClass("package foo.bar.two; public class SecondClass {}"); @@ -175,11 +185,13 @@ public class JavaReflectionCompletionTest extends LightFixtureCompletionTestCase doTest(0, "StringBuffer", "StringBuilder"); } + @NeedsIndicesState.FullIndices public void testClassForNameNestedAutocomplete() { myFixture.addClass("package foo.bar; public class PublicClass { public static class NestedClass {} }"); doTest(-1, () -> assertNull("Auto-completed", myFixture.getLookupElementStrings())); } + @NeedsIndicesState.FullIndices public void testClassForNameNested() { myFixture.addClass("package foo.bar; public class PublicClass {" + " public static class NestedClass {}" + diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionParametersCompletionTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionParametersCompletionTest.kt index e00265ba65b0..5ad80758e19c 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionParametersCompletionTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavaReflectionParametersCompletionTest.kt @@ -21,13 +21,18 @@ import com.intellij.JavaTestUtil import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase import com.intellij.codeInsight.lookup.LookupElement import com.intellij.codeInsight.lookup.LookupElementPresentation +import com.intellij.openapi.util.ThrowableComputable import com.intellij.psi.PsiMethod import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase +import com.intellij.util.indexing.DumbModeAccessType +import com.intellij.util.indexing.FileBasedIndex /** * @author Pavel.Dolgov */ +@NeedsIndicesState.FullIndices class JavaReflectionParametersCompletionTest : LightFixtureCompletionTestCase() { override fun getBasePath(): String = JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/completion/reflectionParameters/" @@ -99,18 +104,23 @@ public class Construct { } } + fun lookupFirstItemsTexts(lookupItems: List, maxSize: Int): List = - lookupItems.subList(0, Math.min(lookupItems.size, maxSize)).map { - val obj = it?.`object` - when (obj) { - is PsiMethod -> { - obj.name + obj.parameterList.parameters.map { it.type.canonicalText + " " + it.name } - .joinToString(",", prefix = "(", postfix = ")") - } - else -> { - val presentation = LookupElementPresentation() - it?.renderElement(presentation) - (presentation.itemText ?: "") + (presentation.tailText ?: "") + // PsiJavaCodeReferenceElementImpl.getCanonicalText needs resolve() + // see JavaReflectionParametersCompletionTest.testConstructor and JavaReflectionParametersCompletionTest.testDeclaredConstructor + FileBasedIndex.getInstance().ignoreDumbMode(DumbModeAccessType.RELIABLE_DATA_ONLY, ThrowableComputable, RuntimeException> { + lookupItems.subList(0, Math.min(lookupItems.size, maxSize)).map { + val obj = it?.`object` + when (obj) { + is PsiMethod -> { + obj.name + obj.parameterList.parameters.map { it.type.canonicalText + " " + it.name } + .joinToString(",", prefix = "(", postfix = ")") + } + else -> { + val presentation = LookupElementPresentation() + it?.renderElement(presentation) + (presentation.itemText ?: "") + (presentation.tailText ?: "") + } } } - } + }) diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavadocCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavadocCompletionTest.groovy index 1d0a558f4708..2872a1b8d9e0 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavadocCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/JavadocCompletionTest.groovy @@ -18,6 +18,7 @@ import com.intellij.psi.codeStyle.JavaCodeStyleSettings import com.intellij.psi.impl.source.resolve.reference.PsiReferenceRegistrarImpl import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry import com.intellij.psi.javadoc.PsiDocTag +import com.intellij.testFramework.NeedsIndicesState import com.intellij.util.ProcessingContext import com.intellij.util.SystemProperties import org.jetbrains.annotations.NotNull @@ -82,16 +83,19 @@ class JavadocCompletionTest extends LightFixtureCompletionTestCase { assertStringItems("a2", "a3") } + @NeedsIndicesState.StandardLibraryIndices void testSee0() { configureByFile("See0.java") myFixture.assertPreferredCompletionItems(0, "foo", "clone", "equals", "hashCode") } + @NeedsIndicesState.StandardLibraryIndices void testSee1() { configureByFile("See1.java") assertStringItems("notify", "notifyAll") } + @NeedsIndicesState.StandardLibraryIndices void testSee2() { configureByFile("See2.java") assertStringItems("notify", "notifyAll") @@ -120,6 +124,7 @@ class JavadocCompletionTest extends LightFixtureCompletionTestCase { assertTrue(getLookupElementStrings().containsAll(Arrays.asList("foo", "myName"))) } + @NeedsIndicesState.StandardLibraryIndices void testIDEADEV10620() { configureByFile("IDEADEV10620.java") @@ -136,6 +141,7 @@ class JavadocCompletionTest extends LightFixtureCompletionTestCase { assertTrue(myItems.length > 18) } + @NeedsIndicesState.StandardLibraryIndices void testException2() { myFixture.configureByFile("Exception2.java") myFixture.complete(CompletionType.SMART) @@ -181,19 +187,23 @@ class JavadocCompletionTest extends LightFixtureCompletionTestCase { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testShortenClassReference() throws Throwable { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.SHORTEN_NAMES_ALWAYS_AND_ADD_IMPORT doTest() } + @NeedsIndicesState.StandardLibraryIndices void testQualifiedClassReference() throws Throwable { configureByFile(getTestName(false) + ".java") myFixture.complete(CompletionType.BASIC, 2) checkResultByFile(getTestName(false) + "_after.java") } + @NeedsIndicesState.StandardLibraryIndices void testQualifiedImportedClassReference() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testThrowsNonImported() throws Throwable { configureByFile(getTestName(false) + ".java") myFixture.complete(CompletionType.BASIC, 2) @@ -210,6 +220,7 @@ class JavadocCompletionTest extends LightFixtureCompletionTestCase { assertTrue(getLookupElementStrings().containsAll(Arrays.asList("io", "lang", "util"))) } + @NeedsIndicesState.FullIndices void testQualifyClassReferenceInPackageStatement() { configureByFile(getTestName(false) + ".java") myFixture.type('\n') @@ -247,6 +258,7 @@ class Foo{} myFixture.assertPreferredCompletionItems 0, 'param', 'param ' } + @NeedsIndicesState.StandardLibraryIndices void "test fqns in package info"() { myFixture.configureByText "package-info.java", ''' /** @@ -314,6 +326,7 @@ class Foo { myFixture.assertPreferredCompletionItems 0, 'some integer param' } + @NeedsIndicesState.FullIndices void "test see super class"() { myFixture.addClass("package foo; public interface Foo {}") myFixture.addClass("package bar; public class Bar {} ") @@ -359,6 +372,7 @@ class Goo { void goo(Foo foo, Bar bar) {} } myFixture.checkResult(text) } + @NeedsIndicesState.StandardLibraryIndices void testShortNameInJavadocIfWasImported() { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.FULLY_QUALIFY_NAMES_IF_NOT_IMPORTED def text = ''' @@ -384,6 +398,7 @@ class Test { ''' } + @NeedsIndicesState.StandardLibraryIndices void testFqnInJavadocIfWasNotImported() { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.FULLY_QUALIFY_NAMES_IF_NOT_IMPORTED def text = ''' @@ -409,7 +424,7 @@ class Test { ''' } - + @NeedsIndicesState.StandardLibraryIndices void testFqnNameInJavadocIfWasImported() { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.FULLY_QUALIFY_NAMES_ALWAYS def text = ''' @@ -435,6 +450,7 @@ class Test { ''' } + @NeedsIndicesState.StandardLibraryIndices void testShortNameInJavadoc() { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.SHORTEN_NAMES_ALWAYS_AND_ADD_IMPORT def text = ''' @@ -460,6 +476,7 @@ class Test { ''' } + @NeedsIndicesState.StandardLibraryIndices void testShortNameInJavadocIfWasImportOnDemand() { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.FULLY_QUALIFY_NAMES_IF_NOT_IMPORTED def text = ''' @@ -522,6 +539,7 @@ public class Test { } + @NeedsIndicesState.StandardLibraryIndices void testShortNameIfImplicitlyImported() { javaSettings.CLASS_NAMES_IN_JAVADOC = JavaCodeStyleSettings.FULLY_QUALIFY_NAMES_IF_NOT_IMPORTED def text = ''' @@ -620,12 +638,14 @@ class Foo { myFixture.checkResult "/** @author $userName */" } + @NeedsIndicesState.StandardLibraryIndices void "test insert link to class"() { myFixture.configureByText 'a.java', "/** FileNotFoEx */" myFixture.completeBasic() myFixture.checkResult "/** {@link java.io.FileNotFoundException} */" } + @NeedsIndicesState.FullIndices void "test insert link to inner class"() { myFixture.addClass('package zoo; public class Outer { public static class FooBarGoo{}}') myFixture.configureByText 'a.java', "/** FooBarGo */" @@ -633,6 +653,7 @@ class Foo { myFixture.checkResult "/** {@link zoo.Outer.FooBarGoo} */" } + @NeedsIndicesState.StandardLibraryIndices void "test insert link to imported class"() { myFixture.configureByText 'a.java', "import java.io.*; /** FileNotFoEx */ class A{}" myFixture.completeBasic() @@ -653,6 +674,7 @@ class Foo { assert !TemplateManagerImpl.getTemplateState(myFixture.editor) } + @NeedsIndicesState.StandardLibraryIndices void "test insert link to method in a q-named class"() { myFixture.configureByText 'a.java', "/** a. java.io.File#liFi */ interface Foo {}" myFixture.completeBasic() @@ -693,6 +715,7 @@ class Foo { myFixture.checkResult "/** @see java.io.IOException */" } + @NeedsIndicesState.StandardLibraryIndices void "test no hierarchical generic method duplicates"() { myFixture.configureByText 'a.java', """ interface Foo { diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/KeywordCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/KeywordCompletionTest.java index 5168dc99f495..98e142dafd52 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/KeywordCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/KeywordCompletionTest.java @@ -9,6 +9,7 @@ import com.intellij.lang.java.JavaLanguage; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.PsiMethod; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import com.intellij.testFramework.NeedsIndicesState; import org.jetbrains.annotations.NotNull; public class KeywordCompletionTest extends LightCompletionTestCase { @@ -96,6 +97,7 @@ public class KeywordCompletionTest extends LightCompletionTestCase { public void testNullInMethodCall() { doTest(); } public void testNullInMethodCall2() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNewInMethodRefs() { doTest(1, "new", "null", "true", "false"); assertEquals("new", LookupElementPresentation.renderElement(myItems[0]).getItemText()); @@ -103,6 +105,7 @@ public class KeywordCompletionTest extends LightCompletionTestCase { checkResultByTestName(); } + @NeedsIndicesState.StandardLibraryIndices public void testNewInMethodRefsArray() { doTest(1, "new", "null", "true", "false"); assertEquals("Object", assertInstanceOf(myItems[0].getPsiElement(), PsiMethod.class).getName()); @@ -111,7 +114,16 @@ public class KeywordCompletionTest extends LightCompletionTestCase { } public void testNewInCast() { doTest(2, "new", "null", "true", "false"); } - public void testNewInNegation() { doTest(1, "new", "null", "true", "false"); } + + public void testNewInNegation() { + if (getIndexingMode() == IndexingMode.DUMB_EMPTY_INDEX) { + // Object's methods are not found in empty indices, so the only element is inserted + doTest(); + } else { + doTest(1, "new", "null", "true", "false"); + } + } + public void testSpaceAfterInstanceof() { doTest(); } public void testInstanceofAfterUnresolved() { doTest(1, "instanceof"); } public void testInstanceofAfterStatementStart() { doTest(1, "instanceof"); } @@ -127,7 +139,9 @@ public class KeywordCompletionTest extends LightCompletionTestCase { public void testNoPrimitivesInBooleanAnnotationAttribute() { doTest(1, "true", "int", "boolean"); } public void testNoPrimitivesInIntAnnotationValueAttribute() { doTest(0, "true", "int", "boolean"); } public void testNoPrimitivesInEnumAnnotationAttribute() { doTest(0, "true", "int", "boolean"); } + @NeedsIndicesState.StandardLibraryIndices public void testPrimitivesInClassAnnotationValueAttribute() { doTest(2, "true", "int", "boolean"); } + @NeedsIndicesState.StandardLibraryIndices public void testPrimitivesInClassAnnotationAttribute() { doTest(3, "true", "int", "boolean"); } public void testPrimitivesInMethodReturningArray() { doTest(2, "true", "byte", "boolean"); } public void testPrimitivesInMethodReturningClass() { doTest(3, "byte", "boolean", "void"); } @@ -181,6 +195,7 @@ public class KeywordCompletionTest extends LightCompletionTestCase { public void testFinalAfterAnnotationAttributes() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testTryInExpression() { configureByTestName(); assertEquals("toString", myItems[0].getLookupString()); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletion4Test.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletion4Test.groovy index 3ac2f8794103..e34366ca2a91 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletion4Test.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletion4Test.groovy @@ -19,9 +19,12 @@ import com.intellij.openapi.projectRoots.Sdk import com.intellij.psi.search.GlobalSearchScope import com.intellij.testFramework.IdeaTestUtil import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.PsiTestUtil import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase +import com.intellij.util.indexing.DumbModeAccessType +import com.intellij.util.indexing.FileBasedIndex import groovy.transform.CompileStatic import org.intellij.lang.annotations.MagicConstant @@ -37,8 +40,11 @@ class MagicConstantCompletion4Test extends LightJavaCodeInsightFixtureTestCase { } } + @NeedsIndicesState.StandardLibraryIndices void "test suppress class constants in MagicConstant presence"() { - assert !myFixture.javaFacade.findClass(MagicConstant.name, GlobalSearchScope.allScope(myFixture.project)) + FileBasedIndex.getInstance().ignoreDumbMode(DumbModeAccessType.RELIABLE_DATA_ONLY, { -> + assert !myFixture.javaFacade.findClass(MagicConstant.name, GlobalSearchScope.allScope(myFixture.project)) + }) myFixture.configureByText "a.java", """import java.util.*; class Bar { diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletionTest.groovy index 1de86afebbb7..306cd865b3a0 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MagicConstantCompletionTest.groovy @@ -18,6 +18,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.codeInsight.completion.CompletionType import com.intellij.codeInsight.lookup.LookupManager import com.intellij.psi.PsiClass +import com.intellij.testFramework.NeedsIndicesState import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase import groovy.transform.CompileStatic import org.intellij.lang.annotations.Language @@ -28,6 +29,7 @@ import org.intellij.lang.annotations.Language @CompileStatic class MagicConstantCompletionTest extends LightJavaCodeInsightFixtureTestCase { + @NeedsIndicesState.FullIndices void "test in method argument"() { addModifierList() myFixture.configureByText "a.java", """ diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MethodChainsCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MethodChainsCompletionTest.java index 362689529f33..2639b8a55e42 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MethodChainsCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/MethodChainsCompletionTest.java @@ -13,12 +13,14 @@ import com.intellij.compiler.chainsSearch.completion.lookup.JavaRelevantChainLoo import com.intellij.openapi.roots.LanguageLevelProjectExtension; import com.intellij.openapi.util.registry.Registry; import com.intellij.pom.java.LanguageLevel; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.testFramework.SkipSlowTestLocally; import com.intellij.util.SmartList; import java.util.List; @SkipSlowTestLocally +@NeedsIndicesState.StandardLibraryIndices public class MethodChainsCompletionTest extends AbstractCompilerAwareTest { private final static String TEST_INDEX_FILE_NAME = "TestIndex.java"; private final static String TEST_COMPLETION_FILE_NAME = "TestCompletion.java"; diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ModuleCompletionTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ModuleCompletionTest.kt index 3f3066afdbfb..262cf647c4f1 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ModuleCompletionTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/ModuleCompletionTest.kt @@ -4,6 +4,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.java.testFramework.fixtures.LightJava9ModulesCodeInsightFixtureTestCase import com.intellij.java.testFramework.fixtures.MultiModuleJava9ProjectDescriptor.ModuleDescriptor.M2 import com.intellij.java.testFramework.fixtures.MultiModuleJava9ProjectDescriptor.ModuleDescriptor.M4 +import com.intellij.testFramework.NeedsIndicesState import org.assertj.core.api.Assertions.assertThat import java.util.jar.JarFile @@ -34,12 +35,15 @@ class ModuleCompletionTest : LightJava9ModulesCodeInsightFixtureTestCase() { fun testStatementsAfterStatement() = variants("module M { requires X; }", "requires", "exports", "opens", "uses", "provides") fun testStatementsUnambiguous() = complete("module M { requires X; ex }", "module M { requires X; exports }") + @NeedsIndicesState.FullIndices fun testRequiresBare() = variants("module M { requires ", "transitive", "static", "M2", "java.base", "java.non.root", "java.se", "java.xml.bind", "java.xml.ws", "lib.multi.release", "lib.named", "lib.auto", "lib.claimed", "all.fours") fun testRequiresTransitive() = complete("module M { requires tr }", "module M { requires transitive }") + @NeedsIndicesState.FullIndices fun testRequiresSimpleName() = complete("module M { requires M }", "module M { requires M2; }") + @NeedsIndicesState.StandardLibraryIndices fun testRequiresQualifiedName() = complete("module M { requires lib.m }", "module M { requires lib.multi.release; }") fun testExportsBare() = variants("module M { exports }", "pkg") @@ -47,9 +51,11 @@ class ModuleCompletionTest : LightJava9ModulesCodeInsightFixtureTestCase() { fun testExportsQualified() = variants("module M { exports pkg. }", "main", "other", "empty") fun testExportsQualifiedUnambiguous() = complete("module M { exports pkg.o }", "module M { exports pkg.other. }") fun testExportsTo() = complete("module M { exports pkg.other }", "module M { exports pkg.other to }") + @NeedsIndicesState.FullIndices fun testExportsToList() = variants("module M { exports pkg.other to }", "M2", "java.base", "java.non.root", "java.se", "java.xml.bind", "java.xml.ws", "lib.multi.release", "lib.named") + @NeedsIndicesState.FullIndices fun testExportsToUnambiguous() = complete("module M { exports pkg.other to M }", "module M { exports pkg.other to M2 }") fun testUsesPrefixed() = complete("module M { uses p }", "module M { uses pkg. }") @@ -69,6 +75,7 @@ class ModuleCompletionTest : LightJava9ModulesCodeInsightFixtureTestCase() { fun testProvidesWithUnambiguous() = complete("module M { provides pkg.main.MySvc with pkg.other.M }", "module M { provides pkg.main.MySvc with pkg.other.MySvcImpl }") + @NeedsIndicesState.FullIndices fun testImports() { addFile("module-info.java", "module M { requires M2; }") addFile("module-info.java", "module M2 { exports pkg.m2; }", M2) diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal11CompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal11CompletionTest.groovy index b20bba592393..e8f2e8563013 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal11CompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal11CompletionTest.groovy @@ -3,6 +3,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.codeInsight.lookup.LookupElement import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic @CompileStatic @@ -57,6 +58,7 @@ class Normal11CompletionTest extends NormalCompletionTestCase { return var } + @NeedsIndicesState.StandardLibraryIndices void testToUnmodifiable() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'collect(Collectors.toUnmodifiableList())', 'collect(Collectors.toUnmodifiableSet())' diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal14CompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal14CompletionTest.groovy index 0500668a0067..6486523a891e 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal14CompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal14CompletionTest.groovy @@ -2,6 +2,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic import org.jetbrains.annotations.NotNull @@ -24,7 +25,8 @@ class Normal14CompletionTest extends NormalCompletionTestCase { myFixture.completeBasic() myFixture.checkResult("record X() cla") } - + + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters generation)") void testRecordAccessorDeclaration() { doTest() } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal6CompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal6CompletionTest.groovy index dece5bca2aac..99e8bc704da3 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal6CompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal6CompletionTest.groovy @@ -2,6 +2,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.codeInsight.lookup.LookupElementPresentation +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic /** @@ -21,12 +22,16 @@ class Normal6CompletionTest extends NormalCompletionTestCase { void testOverwriteGenericsAfterNew() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testExplicitTypeArgumentsWhenParameterTypesDoNotDependOnTypeParameters() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testClassNameWithGenericsTab2() { doTest('\t') } + @NeedsIndicesState.StandardLibraryIndices void testClassNameGenerics() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testDoubleExpectedTypeFactoryMethod() throws Throwable { configure() assertStringItems('Key', 'create', 'create') diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal8CompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal8CompletionTest.groovy index 2968649db84d..5361eca00ab4 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal8CompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/Normal8CompletionTest.groovy @@ -20,6 +20,8 @@ import com.intellij.codeInsight.CodeInsightSettings import com.intellij.codeInsight.lookup.LookupElementPresentation import com.intellij.psi.PsiClass import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState + /** * @author anna */ @@ -67,6 +69,7 @@ class Test { assert LookupElementPresentation.renderElement(items[0]).itemText == 'x1 -> {}' } + @NeedsIndicesState.StandardLibraryIndices void "test lambda signature duplicate parameter name"() { myFixture.configureByText "a.java", """ import java.util.function.Function; @@ -135,6 +138,7 @@ class MethodRef { assert items.find {LookupElementPresentation.renderElement(it).itemText.contains('MethodRef::boo')} } + @NeedsIndicesState.StandardLibraryIndices void "test suggest receiver method reference for generic methods"() { myFixture.configureByText "a.java", """ import java.util.*; @@ -186,6 +190,7 @@ class Test88 { """ } + @NeedsIndicesState.StandardLibraryIndices void testInheritorConstructorRef() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'ArrayList::new', 'ArrayList', 'CopyOnWriteArrayList::new' @@ -218,6 +223,7 @@ class Test88 { assert items.find {LookupElementPresentation.renderElement(it).itemText.contains('Bar::new')} } + @NeedsIndicesState.StandardLibraryIndices void "test new array ref"() { myFixture.configureByText "a.java", """ interface Foo9 { @@ -234,18 +240,21 @@ class Test88 { assert items.find {LookupElementPresentation.renderElement(it).itemText.contains('String[]::new')} } + @NeedsIndicesState.StandardLibraryIndices void testCollectorsToList() { configureByTestName() selectItem(myItems.find { it.lookupString.contains('toList') }) checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testStaticallyImportedCollectorsToList() { configureByTestName() selectItem(myItems.find { it.lookupString.contains('collect(toList())') }) checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testAllCollectors() { configureByTestName() assert myFixture.lookupElementStrings == ['collect', 'collect', 'collect(Collectors.toCollection())', 'collect(Collectors.toList())', 'collect(Collectors.toSet())'] @@ -253,14 +262,17 @@ class Test88 { checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testCollectorsJoining() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCollectorsToSet() { configureByTestName() selectItem(myItems.find { it.lookupString.contains('toSet') }) checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testCollectorsInsideCollect() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'toCollection', 'toList', 'toSet' @@ -268,30 +280,36 @@ class Test88 { checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testCollectorsJoiningInsideCollect() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoExplicitTypeArgsInTernary() { configureByTestName() selectItem(myItems.find { it.lookupString.contains('empty') }) checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testCallBeforeLambda() { configureByTestName() checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testLambdaInAmbiguousCall() { configureByTestName() myFixture.assertPreferredCompletionItems(0, 'toString', 'wait') } + @NeedsIndicesState.StandardLibraryIndices void testLambdaInAmbiguousConstructorCall() { configureByTestName() selectItem(myItems.find { it.lookupString.contains('Empty') }) checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testLambdaWithSuperWildcardInAmbiguousCall() { configureByTestName() myFixture.assertPreferredCompletionItems(0, 'substring', 'substring', 'subSequence') @@ -303,6 +321,7 @@ class Test88 { void testNoContinueInsideLambdaInLoop() { doAntiTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoSemicolonAfterVoidMethodInLambda() { configureByTestName() myFixture.type('l\t') @@ -315,12 +334,14 @@ class Test88 { checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testPreferLocalsOverMethodRefs() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) configureByTestName() myFixture.assertPreferredCompletionItems 0, "psiElement1 -> ", "psiElement", "getParent", "PsiElement" } + @NeedsIndicesState.FullIndices void testStaticallyImportedFromInterface() { myFixture.addClass("package pkg;\n" + "public interface Point {\n" + @@ -331,6 +352,7 @@ class Test88 { checkResultByFileName() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for overriding method completion)") void testOverrideMethodAsDefault() { configureByTestName() assert LookupElementPresentation.renderElement(myFixture.lookupElements[0]).itemText == 'default void run' @@ -338,11 +360,13 @@ class Test88 { checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testChainedMethodReference() { configureByTestName() checkResultByFileName() } + @NeedsIndicesState.FullIndices void testChainedMethodReferenceWithNoPrefix() { myFixture.addClass("package bar; public class Strings {}") myFixture.addClass("package foo; public class Strings { public static void goo() {} }") @@ -350,6 +374,7 @@ class Test88 { myFixture.assertPreferredCompletionItems 0, 'Strings::goo' } + @NeedsIndicesState.StandardLibraryIndices void testOnlyAccessibleClassesInChainedMethodReference() { configureByTestName() def p = LookupElementPresentation.renderElement(assertOneElement(myFixture.lookupElements)) @@ -363,16 +388,19 @@ class Test88 { myFixture.assertPreferredCompletionItems 0, 'output', 'out -> ' } + @NeedsIndicesState.StandardLibraryIndices void testPreferLambdaToConstructorReference() { configureByTestName() myFixture.assertPreferredCompletionItems 0, '() -> ', 'Exception::new' } + @NeedsIndicesState.StandardLibraryIndices void testPreferLambdaToTooGenericLocalVariables() { configureByTestName() myFixture.assertPreferredCompletionItems 0, '(foo, foo2) -> ' } + @NeedsIndicesState.StandardLibraryIndices void testPreferLambdaToRecentSelections() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'String' @@ -401,7 +429,7 @@ class Test88 { } void "test only importable suggestions in import"() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) myFixture.addClass("package com.foo; public class Comments { public static final int B = 2; }") myFixture.configureByText("a.java", "import com.x.y;\n" + "import static java.util.stream.Collectors.joining;") @@ -409,12 +437,14 @@ class Test88 { assert myFixture.lookupElementStrings == ['foo'] } + @NeedsIndicesState.StandardLibraryIndices void "test no overloaded method reference duplicates"() { myFixture.configureByText 'a.java', 'class C { { Runnable r = this::wax; } }' myFixture.completeBasic() assert myFixture.lookupElementStrings == ['wait'] } + @NeedsIndicesState.StandardLibraryIndices void testStreamMethodsOnCollection() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'filter' @@ -428,6 +458,7 @@ class Test88 { checkResultByFileName() } + @NeedsIndicesState.StandardLibraryIndices void testStreamMethodsOnArray() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'length', 'clone' diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionDfaTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionDfaTest.groovy index e7b60a917eff..c7cb4c5520d2 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionDfaTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionDfaTest.groovy @@ -18,6 +18,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.codeInsight.completion.CompletionType import com.intellij.codeInsight.lookup.LookupElementPresentation import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic import org.jetbrains.annotations.NotNull /** @@ -31,8 +32,11 @@ class NormalCompletionDfaTest extends NormalCompletionTestCase { return JAVA_8 } + @NeedsIndicesState.StandardLibraryIndices void testCastInstanceofedQualifier() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastInstanceofedQualifierInForeach() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastComplexInstanceofedQualifier() { doTest() } void _testCastIncompleteInstanceofedQualifier() { doTest() } @@ -40,40 +44,68 @@ class NormalCompletionDfaTest extends NormalCompletionTestCase { void testCastInstanceofedThisQualifier() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testDontCastInstanceofedQualifier() { doTest() } void testDontCastPartiallyInstanceofedQualifier() { doAntiTest() } + @NeedsIndicesState.StandardLibraryIndices void testQualifierCastingWithUnknownAssignments() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testQualifierCastingBeforeLt() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastQualifierForPrivateFieldReference() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testOrAssignmentDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testAssignmentPreciseTypeDfa() { doTestSecond() } + @NeedsIndicesState.StandardLibraryIndices void testAssignmentTwicePreciseTypeDfa() { doTestSecond() } void testAssignmentParameterDfa() { doTest() } void testAssignmentNoPreciseTypeDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testAssignmentPrimitiveLiteral() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testDeclarationPreciseTypeDfa() { doTestSecond() } + @NeedsIndicesState.StandardLibraryIndices void testInstanceOfAssignmentDfa() { doTestSecond() } + @NeedsIndicesState.StandardLibraryIndices void testStreamDfa() { doTest() } + @NeedsIndicesState.FullIndices void testStreamIncompleteDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testOptionalDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testFieldWithCastingCaret() { doTest() } void testCastWhenMethodComesFromDfaSuperType() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testGenericTypeDfa() { doTestSecond() } void testNarrowingReturnType() { doTest() } void testNarrowingReturnTypeInVoidContext() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoUnnecessaryCastDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoUnnecessaryCastRawDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInconsistentHierarchyDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testAfterAssertTrueDfa() { doTest() } void testNoUnnecessaryCastDeepHierarchy() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInstanceOfAfterFunction() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInstanceOfDisjunction() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInstanceOfDisjunction2() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInstanceOfDisjunctionDeep() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInstanceOfDisjunctionCircular() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testAfterGetClass() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoCastForCompatibleCapture() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testBooleanFlagDfa() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testComplexInstanceOfDfa() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'methodFromX', 'methodFromX2', 'methodFromY', 'methodFromY2' @@ -81,11 +113,13 @@ class NormalCompletionDfaTest extends NormalCompletionTestCase { assert LookupElementPresentation.renderElement(myItems[0]).tailText == '() on X' } + @NeedsIndicesState.StandardLibraryIndices void testCastTwice() { configureByTestName() myFixture.assertPreferredCompletionItems 0, 'b', 'a' } + @NeedsIndicesState.FullIndices void testPublicMethodExtendsProtected() { myFixture.addClass ''' package foo; @@ -103,10 +137,13 @@ public class FooImpl extends Foo { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastInstanceofedQualifierInLambda() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastInstanceofedQualifierInLambda2() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastInstanceofedQualifierInExpressionLambda() { doTest() } void testCastQualifierInstanceofedTwice() { @@ -117,6 +154,7 @@ public class FooImpl extends Foo { checkResultByFile(getTestName(false) + "_after.java") } + @NeedsIndicesState.FullIndices void testPreferCastExpressionSuperTypes() { myFixture.addClass('package nonImported; public interface SzNameInTheEnd {}') configureByTestName() diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionOrderingTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionOrderingTest.groovy index a2097d7f304e..8dded7bccc79 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionOrderingTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionOrderingTest.groovy @@ -18,6 +18,7 @@ import com.intellij.openapi.actionSystem.IdeActions import com.intellij.psi.PsiClass import com.intellij.psi.PsiField import com.intellij.psi.PsiMethod +import com.intellij.testFramework.NeedsIndicesState import com.intellij.ui.JBColor class NormalCompletionOrderingTest extends CompletionSortingTestCase { @@ -43,6 +44,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems 0, 'element' } + @NeedsIndicesState.StandardLibraryIndices void testPreferAnnotationMethods() throws Throwable { checkPreferredItems(0, "name", "value", "String", "Foo", "Anno") } @@ -51,10 +53,12 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "foo", "bar") } + @NeedsIndicesState.StandardLibraryIndices void testSubstringVsSubSequence() throws Throwable { checkPreferredItems(0, "substring", "substring", "subSequence") } + @NeedsIndicesState.StandardLibraryIndices void testReturnF() throws Throwable { checkPreferredItems(0, "false", "float", "finalize") } @@ -63,6 +67,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "getName", "getNameIdentifier") } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for html") void testShorterPrefixesGoFirst() throws Throwable { final LookupImpl lookup = invokeCompletion(getTestName(false) + ".html") assertPreferredItems(0, "p", "param", "pre") @@ -71,7 +76,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { } void testUppercaseMatters2() throws Throwable { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.ALL + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.ALL) checkPreferredItems(0, "classLoader", "classLoader2") } @@ -83,6 +88,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "getService", "getService", "class") } + @NeedsIndicesState.StandardLibraryIndices void testGenericityDoesNotMatterWhenNoTypeIsExpected() { checkPreferredItems 0, "generic", "nonGeneric", "clone", "equals" } @@ -91,10 +97,12 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "booleanMethod", "voidMethod", "AN_OBJECT", "BOOLEAN", "class") } + @NeedsIndicesState.StandardLibraryIndices void testPreferClassLiteralWhenClassIsExpected() { checkPreferredItems(0, "class") } + @NeedsIndicesState.StandardLibraryIndices void testJComponentInstanceMembers() throws Throwable { checkPreferredItems(0, "getAccessibleContext", "getUI", "getUIClassID") } @@ -110,6 +118,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "aabbb", "aaa") } + @NeedsIndicesState.FullIndices void testDispreferImpls() throws Throwable { myFixture.addClass("package foo; public class Xxx {}") configureSecondCompletion() @@ -120,6 +129,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "YyyXxx", "YyyZzz") } + @NeedsIndicesState.FullIndices void testPreferTopLevelClasses() throws Throwable { configureSecondCompletion() assertPreferredItems(0, "XxxYyy", "XxzYyy") @@ -130,16 +140,19 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { myFixture.complete(CompletionType.BASIC, 2) } + @NeedsIndicesState.FullIndices void testImplsAfterNew() { myFixture.addClass("package foo; public interface Xxx {}") configureSecondCompletion() assertPreferredItems(0, "XxxImpl", "Xxx") } + @NeedsIndicesState.StandardLibraryIndices void testAfterThrowNew() { checkPreferredItems(0, "Exception", "RuntimeException") } + @NeedsIndicesState.FullIndices void testPreferLessHumps() throws Throwable { myFixture.addClass("package foo; public interface XaYa {}") myFixture.addClass("package foo; public interface XyYa {}") @@ -155,6 +168,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { assertEquals(2, ((PsiMethod)items.get(2).getObject()).getParameterList().getParametersCount()) } + @NeedsIndicesState.FullIndices void testStatsForClassNameInExpression() throws Throwable { myFixture.addClass("package foo; public interface FooBar {}") myFixture.addClass("package foo; public interface FooBee {}") @@ -165,6 +179,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "FooBee", "FooBar") } + @NeedsIndicesState.StandardLibraryIndices void testDispreferFinalize() throws Throwable { checkPreferredItems(0, "final", "finalize") } @@ -177,12 +192,14 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { assertEquals("Foooo.Bar", presentation.getItemText());*/ } + @NeedsIndicesState.StandardLibraryIndices void testDeclaredMembersGoFirst() throws Exception { invokeCompletion(getTestName(false) + ".java") assertStringItems("fromThis", "overridden", "fromSuper", "equals", "hashCode", "toString", "getClass", "notify", "notifyAll", "wait", "wait", "wait") } + @NeedsIndicesState.StandardLibraryIndices void testLocalVarsOverMethods() { checkPreferredItems(0, "value", "validate", "validateTree") } @@ -191,6 +208,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "XcodeProjectTemplate", "XcodeConfigurable") } + @NeedsIndicesState.FullIndices void testFqnStats() { myFixture.addClass("public interface Baaaaaaar {}") myFixture.addClass("package boo; public interface Baaaaaaar {}") @@ -209,15 +227,18 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { assertEquals("boo.Baaaaaaar", ((JavaPsiClassReferenceElement) lookup.items[2]).qualifiedName) } + @NeedsIndicesState.StandardLibraryIndices void testSkipLifted() { checkPreferredItems(0, "hashCodeMine", "hashCode") } + @NeedsIndicesState.StandardLibraryIndices void testDispreferInnerClasses() { checkPreferredItems(0) //no chosen items assertFalse(getLookup().getItems().get(0).getObject() instanceof PsiClass) } + @NeedsIndicesState.StandardLibraryIndices void testPreferSameNamedMethods() { checkPreferredItems(0, "foo", "boo", "doo", "hashCode") } @@ -253,10 +274,12 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "return", "retainAll") } + @NeedsIndicesState.StandardLibraryIndices void testPreferReturnInSingleStatementPlace() { checkPreferredItems 0, "return", "registerKeyboardAction" } + @NeedsIndicesState.StandardLibraryIndices void testPreferContinueInsideLoops() { checkPreferredItems 0, "continue", "color", "computeVisibleRect" } @@ -269,6 +292,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "MyEnum.bar", "MyEnum", "MyEnum.foo") } + @NeedsIndicesState.FullIndices void testPreferExpectedEnumConstantsDespiteStats() { checkPreferredItems 0, "const1", "const2", "constx1", "constx2" myFixture.lookup.currentItem = myFixture.lookupElements[2] @@ -303,6 +327,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "Bar9", "Bar1", "Bar2", "Bar3", "Bar4") } + @NeedsIndicesState.FullIndices void testPreselectMostRelevantInTheMiddleAlpha() { UISettings.getInstance().setSortLookupElementsLexicographically(true) @@ -322,6 +347,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { assert myFixture.lookupElementStrings.sort() == myFixture.lookupElementStrings } + @NeedsIndicesState.FullIndices void testAlphaSortPackages() { UISettings.getInstance().setSortLookupElementsLexicographically(true) @@ -340,6 +366,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems 0, 'xxbar', 'xxfoo', 'xxgoo', 'barxx', 'fooxx', 'gooxx' } + @NeedsIndicesState.FullIndices void testSortSameNamedVariantsByProximity() { myFixture.addClass("public class Bar {}") for (int i = 0; i < 10; i++) { @@ -356,10 +383,11 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { } void testCaseInsensitivePrefixMatch() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) checkPreferredItems(1, "Foo", "foo1", "foo2") } + @NeedsIndicesState.StandardLibraryIndices void testPreferKeywordsToVoidMethodsInExpectedTypeContext() { checkPreferredItems 0, 'noo', 'new', 'null', 'noo2', 'notify', 'notifyAll' } @@ -368,6 +396,7 @@ class NormalCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems 0, 'serial', 'superExpressionInIllegalContext' } + @NeedsIndicesState.StandardLibraryIndices void testPreferApplicableAnnotations() throws Throwable { myFixture.addClass ''' import java.lang.annotation.ElementType; @@ -381,6 +410,7 @@ import java.lang.annotation.Target; checkPreferredItems 0, 'TMetaAnno', 'Target', 'TabLayoutPolicy', 'TabPlacement' } + @NeedsIndicesState.StandardLibraryIndices void testPreferApplicableAnnotationsMethod() throws Throwable { myFixture.addClass ''' import java.lang.annotation.ElementType; @@ -397,6 +427,7 @@ interface TxANotAnno {} assert !('TxANotAnno' in myFixture.lookupElementStrings) } + @NeedsIndicesState.StandardLibraryIndices void testJComponentAddNewWithStats() throws Throwable { final LookupImpl lookup = invokeCompletion("/../smartTypeSorting/JComponentAddNew.java") assertPreferredItems(0, "FooBean3", "JComponent", "Component") @@ -420,10 +451,12 @@ interface TxANotAnno {} checkPreferredItems 0, 'returnMethod', 'return' } + @NeedsIndicesState.StandardLibraryIndices void testDispreferReturnInVoidLambda() { checkPreferredItems 0, 'reaction', 'rezet', 'return' } + @NeedsIndicesState.StandardLibraryIndices void testDoNotPreferGetClass() { checkPreferredItems 0, 'get', 'getClass' incUseCount(lookup, 1) @@ -432,6 +465,7 @@ interface TxANotAnno {} assertPreferredItems 0, 'get', 'getClass' } + @NeedsIndicesState.StandardLibraryIndices void testEqualsStats() { checkPreferredItems 0, 'equals', 'equalsIgnoreCase' incUseCount(lookup, 1) @@ -444,6 +478,7 @@ interface TxANotAnno {} checkPreferredItems 0, 'MyCalendar.FIELD_COUNT', 'MyCalendar', 'MyCalendar.AM' } + @NeedsIndicesState.FullIndices void testPreferLocalsToStaticsInSecondCompletion() { myFixture.addClass('public class FooZoo { public static void fooBar() {} }') myFixture.addClass('public class fooAClass {}') @@ -461,7 +496,7 @@ interface TxANotAnno {} } void testUnderscoresDontMakeMatchMiddle() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) checkPreferredItems(0, 'fooBar', '_fooBar', 'FooBar') } @@ -486,6 +521,7 @@ interface TxANotAnno {} assert lookup.items[1].object instanceof PsiMethod } + @NeedsIndicesState.StandardLibraryIndices void testPreselectLastChosen() { checkPreferredItems(0, 'add', 'addAll') for (i in 0..10) { @@ -542,7 +578,7 @@ interface TxANotAnno {} } void testCommonPrefixMoreImportantThanKind() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) checkPreferredItems(0, 'PsiElement', 'psiElement') } @@ -551,7 +587,7 @@ interface TxANotAnno {} } void testLocalVarsOverStats() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) checkPreferredItems 0, 'psiElement', 'PsiElement' incUseCount lookup, 1 assertPreferredItems 0, 'psiElement', 'PsiElement' @@ -582,6 +618,7 @@ interface TxANotAnno {} checkPreferredItems 0, 'MyEnum.BAR', 'MyEnum', 'MyEnum.FOO' } + @NeedsIndicesState.StandardLibraryIndices void testPreferClassesOfExpectedClassType() { myFixture.addClass "class XException extends Exception {}" checkPreferredItems 0, 'XException', 'XClass', 'XIntf' @@ -595,19 +632,22 @@ interface TxANotAnno {} checkPreferredItems 0, 'fact' } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for 'Override/Implement methods...')") void testPreferAnnotationsToInterfaceKeyword() { checkPreferredItems 0, 'Override/Implement methods...', 'Override', 'Deprecated' } + @NeedsIndicesState.StandardLibraryIndices void testPreferThrownExceptionsInCatch() { checkPreferredItems 0, 'final', 'FileNotFoundException', 'File' } void testHonorFirstLetterCase() { - CodeInsightSettings.getInstance().COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.getInstance().setCompletionCaseSensitive(CodeInsightSettings.NONE) checkPreferredItems 0, 'posIdMap', 'PImageDecoder', 'PNGImageDecoder' } + @NeedsIndicesState.FullIndices void testGlobalStaticMemberStats() { configureNoCompletion(getTestName(false) + ".java") myFixture.complete(CompletionType.BASIC, 2) @@ -616,10 +656,12 @@ interface TxANotAnno {} assertPreferredItems 0, 'newLinkedSet1', 'newLinkedSet0', 'newLinkedSet2' } + @NeedsIndicesState.StandardLibraryIndices void testStaticMemberTypes() { checkPreferredItems 0, 'newMap', 'newList' } + @NeedsIndicesState.StandardLibraryIndices void testNoStatsInSuperInvocation() { checkPreferredItems 0, 'put', 'putAll' @@ -638,6 +680,7 @@ interface TxANotAnno {} assert lookup.items.find { it.lookupString == 'ritar'} != null } + @NeedsIndicesState.StandardLibraryIndices void testPreferLocalToExpectedTypedMethod() { checkPreferredItems 0, 'event', 'equals' } @@ -653,12 +696,14 @@ interface TxANotAnno {} assert LookupElementPresentation.renderElement(items.find { it.lookupString == 'BAR' }).itemTextForeground == JBColor.RED } + @NeedsIndicesState.StandardLibraryIndices void testPreferValueTypesReturnedFromMethod() { checkPreferredItems 0, 'StringBuffer', 'String', 'Serializable', 'SomeInterface', 'SomeInterface', 'SomeOtherClass' assert 'SomeInterface' == LookupElementPresentation.renderElement(myFixture.lookupElements[3]).itemText assert 'SomeInterface' == LookupElementPresentation.renderElement(myFixture.lookupElements[4]).itemText } + @NeedsIndicesState.FullIndices void testPreferCastTypesHavingSpecifiedMethod() { checkPreferredItems 0, 'MainClass1', 'MainClass2', 'Maa' } @@ -667,14 +712,17 @@ interface TxANotAnno {} checkPreferredItems 0, 'fun1', 'fun2', 'fun10' } + @NeedsIndicesState.StandardLibraryIndices void testPreferVarsHavingReferencedMember() { checkPreferredItems 0, 'xzMap', 'xaString' } + @NeedsIndicesState.StandardLibraryIndices void testPreferCollectionsStaticOfExpectedType() { checkPreferredItems 0, 'unmodifiableList', 'unmodifiableCollection' } + @NeedsIndicesState.FullIndices void testDispreferDeprecatedMethodWithUnresolvedQualifier() { myFixture.addClass("package foo; public class Assert { public static void assertTrue() {} }") myFixture.addClass("package bar; @Deprecated public class Assert { public static void assertTrue() {}; public static void assertTrue2() {} }") @@ -701,6 +749,7 @@ interface TxANotAnno {} checkPreferredItems 0, 'false', 'factory' } + @NeedsIndicesState.FullIndices void testPreferExplicitlyImportedStaticMembers() { myFixture.addClass(""" class ContainerUtilRt { @@ -720,6 +769,7 @@ class ContainerUtil extends ContainerUtilRt { checkPreferredItems 0, 'catch', 'finally' } + @NeedsIndicesState.FullIndices void testPreselectClosestExactPrefixItem() { UISettings.instance.setSortLookupElementsLexicographically(true) myFixture.addClass 'package pack1; public class SameNamed {}' @@ -729,6 +779,7 @@ class ContainerUtil extends ContainerUtilRt { assert LookupElementPresentation.renderElement(myFixture.lookupElements[1]).tailText.contains('pack2') } + @NeedsIndicesState.StandardLibraryIndices void testPreferExpectedMethodTypeArg() { checkPreferredItems 0, 'String', 'Usage' @@ -750,6 +801,7 @@ class ContainerUtil extends ContainerUtilRt { myFixture.assertPreferredCompletionItems 0, 'String', "Usage" } + @NeedsIndicesState.StandardLibraryIndices void testMethodStatisticsPerQualifierType() { checkPreferredItems 0, 'charAt' myFixture.type('eq\n);\n') @@ -760,6 +812,7 @@ class ContainerUtil extends ContainerUtilRt { assertPreferredItems 0, 'someMethod' } + @NeedsIndicesState.FullIndices void testPreferImportedClassesAmongstSameNamed() { myFixture.addClass('package foo; public class String {}') @@ -786,12 +839,14 @@ class ContainerUtil extends ContainerUtilRt { assertPreferredItems 0, 'ContainerUtil', 'ConflictsUtil' } + @NeedsIndicesState.StandardLibraryIndices void testPreferListAddWithoutIndex() { checkPreferredItems 0, 'add', 'add', 'addAll', 'addAll' assert LookupElementPresentation.renderElement(myFixture.lookupElements[1]).tailText.contains('int index') assert LookupElementPresentation.renderElement(myFixture.lookupElements[3]).tailText.contains('int index') } + @NeedsIndicesState.FullIndices void testPreferExpectedTypeConstantOverSameNamedClass() { myFixture.addClass("package another; public class JSON {}") checkPreferredItems 0, 'Point.JSON', 'JSON' @@ -835,6 +890,7 @@ class Foo { myFixture.assertPreferredCompletionItems 0, 'a', 'b', 'a, b' } + @NeedsIndicesState.StandardLibraryIndices void "test selecting static field after static method"() { myFixture.configureByText 'a.java', 'class Foo { { System. } }' myFixture.completeBasic() @@ -850,14 +906,17 @@ class Foo { myFixture.assertPreferredCompletionItems 0, 'out', 'exit' } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters)") void testPreferTypeToGeneratedMethod() { checkPreferredItems 0, 'SomeClass', 'public SomeClass getZoo' } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters and equals())") void testPreferPrimitiveTypeToGeneratedMethod() { checkPreferredItems 0, 'boolean', 'public boolean isZoo', 'public boolean equals' } + @NeedsIndicesState.StandardLibraryIndices void testPreferExceptionsInCatch() { myFixture.configureByText 'a.java', 'class Foo { { Enu } }' myFixture.completeBasic() @@ -867,14 +926,17 @@ class Foo { myFixture.assertPreferredCompletionItems 0, 'Exception', 'Error' } + @NeedsIndicesState.StandardLibraryIndices void testPreferExceptionsInThrowsList() { checkPreferredItems 0, 'IllegalStateException', 'IllegalAccessException', 'IllegalArgumentException' } + @NeedsIndicesState.StandardLibraryIndices void testPreferExceptionsInJavadocThrows() { checkPreferredItems 0, 'IllegalArgumentException', 'IllegalAccessException', 'IllegalStateException' } + @NeedsIndicesState.StandardLibraryIndices void testPreferExpectedTypeArguments() { checkPreferredItems 0, 'BlaOperation' } @@ -883,6 +945,7 @@ class Foo { checkPreferredItems 0, 'final', 'find1' } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testDispreferMultiMethodInterfaceAfterNew() { checkPreferredItems 1, 'Intf', 'IntfImpl' } @@ -895,6 +958,7 @@ class Foo { checkPreferredItems 0, 'AbstractListener', 'Listener' } + @NeedsIndicesState.StandardLibraryIndices void testPreferPrintln() { myFixture.configureByText 'a.java', 'class Foo { { System.out.prix } }' myFixture.completeBasic() diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy index 3f0a6da8a10f..c45f1dcacd10 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/NormalCompletionTest.groovy @@ -20,6 +20,7 @@ import com.intellij.psi.codeStyle.CodeStyleSettingsManager import com.intellij.psi.codeStyle.CommonCodeStyleSettings import com.intellij.psi.codeStyle.JavaCodeStyleSettings import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.NeedsIndicesState import com.intellij.util.ui.UIUtil import com.siyeh.ig.style.UnqualifiedFieldAccessInspection import groovy.transform.CompileStatic @@ -84,6 +85,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { doTest 'a\n' } + @NeedsIndicesState.StandardLibraryIndices void testSimpleVariable() throws Exception { doTest('\n') } void testTypeParameterItemPresentation() { @@ -114,6 +116,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert presentation.tailText == ' default "unknown"' } + @NeedsIndicesState.StandardLibraryIndices void testMethodItemPresentation() { configure() LookupElementPresentation presentation = renderElement(myItems[0]) @@ -137,6 +140,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert "String" == presentation.typeText } + @NeedsIndicesState.StandardLibraryIndices void testMethodItemPresentationGenerics() { configure() LookupElementPresentation presentation = renderElement(myItems[1]) @@ -175,18 +179,21 @@ class NormalCompletionTest extends NormalCompletionTestCase { configureByFile("SCR7208.java") } + @NeedsIndicesState.StandardLibraryIndices void testProtectedFromSuper() throws Exception { configureByFile("ProtectedFromSuper.java") Arrays.sort(myItems) assertTrue("Exception not found", Arrays.binarySearch(myItems, "xxx") > 0) } + @NeedsIndicesState.StandardLibraryIndices void testBeforeInitialization() throws Exception { configureByFile("BeforeInitialization.java") assertNotNull(myItems) assertTrue(myItems.length > 0) } + @NeedsIndicesState.StandardLibraryIndices void testProtectedFromSuper2() throws Exception { configureByFile("ProtectedFromSuper.java") @@ -207,7 +214,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { @Override protected void tearDown() throws Exception { CodeInsightSettings.instance.AUTOCOMPLETE_ON_CODE_COMPLETION = true - CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER + CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.FIRST_LETTER) CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = true super.tearDown() } @@ -224,6 +231,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert 'ABCDE' in myFixture.lookupElementStrings } + @NeedsIndicesState.StandardLibraryIndices void testObjectsInThrowsBlock() throws Exception { configureByFile("InThrowsCompletion.java") assert "C" == myFixture.lookupElementStrings[0] @@ -286,6 +294,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { void testSecondSwitchCaseWithEnumConstant() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testInsideSwitchCaseWithEnumConstant() { configure() myFixture.assertPreferredCompletionItems 0, 'compareTo', 'equals' @@ -387,10 +396,12 @@ class NormalCompletionTest extends NormalCompletionTestCase { void testAnonymousTypeParameter() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testClassLiteralInAnnoParam() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoForceBraces() { codeStyleSettings.IF_BRACE_FORCE = CommonCodeStyleSettings.FORCE_BRACES_ALWAYS doTest('\n') @@ -402,6 +413,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert !('StringBuffer' in myFixture.lookupElementStrings) } + @NeedsIndicesState.FullIndices void testExcludeInstanceInnerClasses() throws Throwable { JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo") myFixture.addClass 'package foo; public class Outer { public class Inner {} }' @@ -411,6 +423,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert myFixture.lookupElementStrings == ['Inner'] } + @NeedsIndicesState.FullIndices void testExcludedInstanceInnerClassCreation() throws Throwable { JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo") myFixture.addClass 'package foo; public class Outer { public class Inner {} }' @@ -420,6 +433,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert myFixture.lookupElementStrings == ['Inner'] } + @NeedsIndicesState.FullIndices void testExcludedInstanceInnerClassQualifiedReference() throws Throwable { JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo") myFixture.addClass 'package foo; public class Outer { public class Inner {} }' @@ -429,6 +443,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert myFixture.lookupElementStrings == ['Inner'] } + @NeedsIndicesState.FullIndices void testStaticMethodOfExcludedClass() { JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo") myFixture.addClass 'package foo; public class Outer { public static void method() {} }' @@ -436,6 +451,7 @@ class NormalCompletionTest extends NormalCompletionTestCase { assert myFixture.lookupElementStrings == ['method'] } + @NeedsIndicesState.FullIndices void testExcludeWildcards() { JavaProjectCodeInsightSettings.setExcludedNames(project, myFixture.testRootDisposable, "foo.Outer.*1*") myFixture.addClass ''' @@ -451,6 +467,7 @@ public class Outer { assert myFixture.lookupElementStrings == ['method2', 'method42'] } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for int hashCode lookup preventing autocompletion and additional \n)") void testAtUnderClass() throws Throwable { doTest('\n') } @@ -469,16 +486,19 @@ public class Outer { assert 'K' in myFixture.lookupElementStrings } + @NeedsIndicesState.StandardLibraryIndices void testLocalClassTwice() throws Throwable { configure() assertOrderedEquals myFixture.lookupElementStrings, 'Zoooz', 'Zooooo', 'ZipOutputStream' } + @NeedsIndicesState.StandardLibraryIndices void testLocalTopLevelConflict() throws Throwable { configure() assertOrderedEquals myFixture.lookupElementStrings, 'Zoooz', 'Zooooo', 'ZipOutputStream' } + @NeedsIndicesState.StandardLibraryIndices void testFinalBeforeMethodCall() throws Throwable { configure() assertStringItems 'final', 'finalize' @@ -574,6 +594,7 @@ public class Outer { }}""".stripIndent()) } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") void testAnonymousProcess() { myFixture.addClass 'package java.lang; public class Process {}' myFixture.addClass ''' @@ -604,6 +625,7 @@ public class ListUtils { assertStringItems("case", "default") } + @NeedsIndicesState.StandardLibraryIndices void testBooleanLiterals() throws Throwable { doTest('\n') } @@ -622,6 +644,7 @@ public class ListUtils { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testChainedCallOnNextLine() throws Throwable { configureByFile(getTestName(false) + ".java") selectItem(myItems[0]) @@ -636,6 +659,7 @@ public class ListUtils { void testEnclosingThis() throws Throwable { doTest() } + @NeedsIndicesState.FullIndices void testSeamlessConstant() throws Throwable { configureByFile(getTestName(false) + ".java") selectItem(myItems[0]) @@ -651,6 +675,7 @@ public class ListUtils { checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testNoSpaceInParensWithoutParams() throws Throwable { codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true try { @@ -661,25 +686,30 @@ public class ListUtils { } } + @NeedsIndicesState.StandardLibraryIndices void testTwoSpacesInParensWithParams() throws Throwable { codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true doTest() } + @NeedsIndicesState.StandardLibraryIndices void testQualifierAsPackage() throws Throwable { configureByFile(getTestName(false) + ".java") selectItem(myItems[0]) checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testQualifierAsPackage2() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testQualifierAsPackage3() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testPreselectEditorSelection() { configure() assert lookup.currentItem != myFixture.lookupElements[0] @@ -691,8 +721,10 @@ public class ListUtils { assertStringItems("*") } + @NeedsIndicesState.StandardLibraryIndices void testMembersInStaticImports() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testPackageNamedVariableBeforeAssignment() throws Throwable { doTest() } @@ -718,6 +750,7 @@ public class ListUtils { assert myFixture.lookupElementStrings == ['MyParam'] } + @NeedsIndicesState.StandardLibraryIndices void testMethodReturnType() { doTest('\n') } void testMethodReturnTypeNoSpace() throws Throwable { @@ -730,6 +763,7 @@ public class ListUtils { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testDoWhileMethodCall() throws Throwable { doTest() } @@ -738,6 +772,7 @@ public class ListUtils { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testGetterWithExistingNonEmptyParameterList() throws Throwable { doTest() } @@ -762,6 +797,7 @@ public class ListUtils { doTest('.') } + @NeedsIndicesState.StandardLibraryIndices void testFinishClassNameWithLParen() throws Throwable { doTest('(') } @@ -774,6 +810,7 @@ public class ListUtils { checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testCompletionInsideClassLiteral() throws Throwable { configureByFile(getTestName(false) + ".java") type('\n') @@ -790,6 +827,7 @@ public class ListUtils { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testSuperInConstructorWithParams() throws Throwable { doTest() } @@ -845,16 +883,19 @@ public class ListUtils { assertStringItems("fofoo", "fofoo") } + @NeedsIndicesState.StandardLibraryIndices void testMethodMergingMinimalTail() { doTest() } void testAnnotationQualifiedName() throws Throwable { doTest() } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") void testClassNameAnonymous() throws Throwable { doTest('\n') } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") void testClassNameWithInner() throws Throwable { configure() assertStringItems 'Zzoo', 'Zzoo.Impl' @@ -866,6 +907,7 @@ public class ListUtils { void testClassNameWithInstanceInner() throws Throwable { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testDoubleFalse() throws Throwable { configureByFile(getTestName(false) + ".java") assertFirstStringItems("false", "fefefef", "float", "finalize") @@ -882,6 +924,7 @@ public class ListUtils { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testNoSemicolonAfterExistingParenthesesEspeciallyIfItsACast() throws Throwable { doTest() } void testReturningTypeVariable() throws Throwable { doTest() } @@ -890,6 +933,7 @@ public class ListUtils { void testReturningTypeVariable3() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testImportInGenericType() throws Throwable { configure() myFixture.complete(CompletionType.BASIC, 2) @@ -910,6 +954,7 @@ public class ListUtils { assertStringItems 'final' } + @NeedsIndicesState.StandardLibraryIndices void testFinalInForLoop2() throws Throwable { configure() myFixture.assertPreferredCompletionItems 0, 'finalize', 'final' @@ -960,6 +1005,7 @@ public class ListUtils { assertStringItems("fai1", "fai2") } + @NeedsIndicesState.FullIndices void testProtectedInaccessibleOnSecondInvocation() throws Throwable { myFixture.configureByFile(getTestName(false) + ".java") myFixture.complete(CompletionType.BASIC, 2) @@ -972,6 +1018,7 @@ public class ListUtils { doAntiTest() } + @NeedsIndicesState.StandardLibraryIndices void testSecondAnonymousClassParameter() { doTest() } void testSpaceAfterReturn() throws Throwable { @@ -1000,6 +1047,7 @@ public class ListUtils { void testSmartEnterWithNewLine() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) } + @NeedsIndicesState.SmartMode(reason = "MethodCallFixer.apply needs smart mode to count number of parameters") void testSmartEnterGuessArgumentCount() throws Throwable { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) } void testSmartEnterInsideArrayBrackets() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) } @@ -1008,6 +1056,7 @@ public class ListUtils { void testMethodParameterAnnotationClass() throws Throwable { doTest() } + @NeedsIndicesState.FullIndices void testInnerAnnotation() { configure() assert myFixture.lookupElementStrings == ['Dependency'] @@ -1022,7 +1071,7 @@ public class ListUtils { void testClassReferenceInFor2() throws Throwable { doTest ' ' } void testClassReferenceInFor3() throws Throwable { - CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE) doTest ' ' } @@ -1049,17 +1098,20 @@ public class ListUtils { void testExpectedTypesDotSelectsItem() throws Throwable { doTest('.') } + @NeedsIndicesState.FullIndices void testExpectedTypeMembersVersusStaticImports() throws Throwable { configure() assertStringItems('XFOO', 'XFOX') } + @NeedsIndicesState.FullIndices void testSuggestExpectedTypeMembersNonImported() throws Throwable { myFixture.addClass("package foo; public class Super { public static final Super FOO = null; }") myFixture.addClass("package foo; public class Usage { public static void foo(Super s) {} }") doTest('\n') } + @NeedsIndicesState.FullIndices void testStaticallyImportedInner() throws Throwable { configure() assertStringItems('AIOInner', 'ArrayIndexOutOfBoundsException') @@ -1078,6 +1130,7 @@ public class ListUtils { void testOnlyAnnotationsAfterAt() throws Throwable { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testOnlyAnnotationsAfterAt2() throws Throwable { doTest('\n') } void testAnnotationBeforeIdentifier() { doTest('\n') } @@ -1086,12 +1139,16 @@ public class ListUtils { void testAnnotationBeforeIdentifierFinishWithSpace() { doTest(' ') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyExceptionsInCatch1() throws Exception { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyExceptionsInCatch2() throws Exception { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyExceptionsInCatch3() throws Exception { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyExceptionsInCatch4() throws Exception { doTest('\n') } void testCommaAfterVariable() throws Throwable { doTest(',') } @@ -1110,6 +1167,7 @@ public class ListUtils { void testMethodParameterTypeDot() throws Throwable { doAntiTest() } + @NeedsIndicesState.StandardLibraryIndices void testNewGenericClass() throws Throwable { doTest('\n') } void testNewGenericInterface() throws Throwable { doTest() } @@ -1132,6 +1190,7 @@ public class ListUtils { assertStringItems("MyParameter", "MySecondParameter") } + @NeedsIndicesState.FullIndices void testSuperProtectedMethod() throws Throwable { myFixture.addClass """package foo; public class Bar { @@ -1140,6 +1199,7 @@ public class ListUtils { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testOuterSuperMethodCall() { configure() assert 'Class2.super.put' == LookupElementPresentation.renderElement(myItems[0]).itemText @@ -1160,6 +1220,7 @@ public class ListUtils { assertStringItems("myField1", "myField2") } + @NeedsIndicesState.StandardLibraryIndices void testAfterCommonPrefix() throws Throwable { configure() type 'eq' @@ -1170,6 +1231,7 @@ public class ListUtils { checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testClassNameInsideIdentifierInIf() throws Throwable { configure() myFixture.complete(CompletionType.BASIC, 2) @@ -1185,6 +1247,7 @@ public class ListUtils { } void testSynchronizedArgumentSmartEnter() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) } + @NeedsIndicesState.FullIndices void testImportStringValue() throws Throwable { myFixture.addClass("package foo; public class StringValue {}") myFixture.addClass("package java.lang; class StringValue {}") @@ -1196,6 +1259,7 @@ public class ListUtils { void testPrimitiveArrayWithRBrace() throws Throwable { doTest '[' } + @NeedsIndicesState.FullIndices void testSuggestMembersOfStaticallyImportedClasses() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -1206,6 +1270,7 @@ public class ListUtils { doTest('\n') } + @NeedsIndicesState.FullIndices void testSuggestMembersOfStaticallyImportedClassesUnqualifiedOnly() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -1220,6 +1285,7 @@ public class ListUtils { checkResult() } + @NeedsIndicesState.FullIndices void testSuggestMembersOfStaticallyImportedClassesConflictWithLocalMethod() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -1235,6 +1301,7 @@ public class ListUtils { checkResult() } + @NeedsIndicesState.FullIndices void testSuggestMembersOfStaticallyImportedClassesConflictWithLocalField() throws Exception { myFixture.addClass("""package foo; public class Foo { @@ -1282,6 +1349,7 @@ public class ListUtils { assertFirstStringItems "final", "float" } + @NeedsIndicesState.FullIndices void testNonImportedClassInAnnotation() { myFixture.addClass("package foo; public class XInternalTimerServiceController {}") myFixture.configureByText "a.java", """ @@ -1295,6 +1363,7 @@ class XInternalError {} assertFirstStringItems "XInternalError", "XInternalTimerServiceController" } + @NeedsIndicesState.FullIndices void testNonImportedAnnotationClass() { myFixture.addClass("package foo; public @interface XAnotherAnno {}") configure() @@ -1302,6 +1371,7 @@ class XInternalError {} assertFirstStringItems "XAnno", "XAnotherAnno" } + @NeedsIndicesState.StandardLibraryIndices void testMetaAnnotation() { myFixture.configureByText "a.java", "@ @interface Anno {}" myFixture.complete(CompletionType.BASIC) @@ -1310,6 +1380,7 @@ class XInternalError {} void testAnnotationClassFromWithinAnnotation() { doTest() } + @NeedsIndicesState.FullIndices void testStaticallyImportedFieldsTwice() { myFixture.addClass(""" class Foo { @@ -1364,7 +1435,7 @@ class XInternalError {} } void testDontPreselectCaseInsensitivePrefixMatch() { - CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE) myFixture.configureByText "a.java", "import java.io.*; class Foo {{ int fileSize; filx }}" myFixture.completeBasic() assert lookup.currentItem.lookupString == 'fileSize' @@ -1375,21 +1446,26 @@ class XInternalError {} assert lookup.currentItem == lookup.items[1] } + @NeedsIndicesState.StandardLibraryIndices void testNoGenericsWhenChoosingWithParen() { doTest('Ma(') } + @NeedsIndicesState.StandardLibraryIndices void testNoClosingWhenChoosingWithParenBeforeIdentifier() { doTest '(' } void testPackageInMemberType() { doTest() } void testPackageInMemberTypeGeneric() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testConstantInAnno() { doTest('\n') } + @NeedsIndicesState.SmartMode(reason = "Smart mode needed for EncodingReferenceInjector to provide EncodingReference with variants") void testCharsetName() { myFixture.addClass("package java.nio.charset; public class Charset { public static Charset forName(String s) {} }") configureByTestName() assert myFixture.lookupElementStrings.contains('UTF-8') } + @NeedsIndicesState.FullIndices void testInnerClassInExtendsGenerics() { def text = "package bar; class Foo extends List> { public static class Inner {} }" myFixture.configureFromExistingVirtualFile(myFixture.addClass(text).containingFile.virtualFile) @@ -1398,8 +1474,10 @@ class XInternalError {} myFixture.checkResult(text.replace('Inne', 'Foo.Inner')) } + @NeedsIndicesState.StandardLibraryIndices void testClassNameDot() { doTest('.') } + @NeedsIndicesState.FullIndices void testClassNameDotBeforeCall() { myFixture.addClass("package foo; public class FileInputStreamSmth {}") myFixture.configureByFile(getTestName(false) + ".java") @@ -1417,6 +1495,7 @@ class XInternalError {} assert !('return' in myFixture.lookupElementStrings) } + @NeedsIndicesState.StandardLibraryIndices void testDuplicateExpectedTypeInTypeArgumentList() { configure() def items = myFixture.lookupElements.findAll { it.lookupString == 'String' } @@ -1438,8 +1517,10 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testNoParenthesesAroundCallQualifier() { doTest() } + @NeedsIndicesState.FullIndices void testAllAssertClassesMethods() { myFixture.addClass 'package foo; public class Assert { public static boolean foo() {} }' myFixture.addClass 'package bar; public class Assert { public static boolean bar() {} }' @@ -1449,6 +1530,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.FullIndices void testCastVisually() { configure() def p = LookupElementPresentation.renderElement(myFixture.lookupElements[0]) @@ -1457,6 +1539,7 @@ class XInternalError {} assert p.typeText == 'Foo' } + @NeedsIndicesState.StandardLibraryIndices void testSuggestEmptySet() { configure() assert 'emptySet' == myFixture.lookupElementStrings[0] @@ -1464,6 +1547,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testSuggestAllTypeArguments() { configure() assert 'String, List' == lookup.items[0].lookupString @@ -1474,12 +1558,15 @@ class XInternalError {} void testNoFinalInAnonymousConstructor() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testListArrayListCast() { doTest('\n') } void testInterfaceImplementationNoCast() { doTest() } + @NeedsIndicesState.FullIndices void testStaticallyImportedMethodsBeforeExpression() { doTest() } + @NeedsIndicesState.FullIndices void testInnerChainedReturnType() { doTest() } private CommonCodeStyleSettings getCodeStyleSettings() { @@ -1497,6 +1584,7 @@ class XInternalError {} assert lookup.items.size() == 1 } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for method implementations)") void testImplementViaCompletion() { configure() myFixture.assertPreferredCompletionItems 0, 'private', 'protected', 'public', 'public void run' @@ -1512,6 +1600,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for implementing methods)") void testImplementViaCompletionWithGenerics() { configure() myFixture.assertPreferredCompletionItems 0, 'public void methodWithGenerics', 'public void methodWithTypeParam' @@ -1519,6 +1608,7 @@ class XInternalError {} assert LookupElementPresentation.renderElement(lookup.items[1]).tailText == '(K k) {...}' } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants provides dialog option in smart mode only") void testImplementViaOverrideCompletion() { configure() myFixture.assertPreferredCompletionItems 0, 'Override/Implement methods...', 'Override', 'public void run' @@ -1527,6 +1617,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants provides dialog option in smart mode only") void testSuggestToOverrideMethodsWhenTypingOverrideAnnotation() { configure() myFixture.assertPreferredCompletionItems 0, 'Override/Implement methods...', 'Override' @@ -1534,6 +1625,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants provides dialog option in smart mode only") void testSuggestToOverrideMethodsWhenTypingOverrideAnnotationBeforeMethod() { configure() myFixture.assertPreferredCompletionItems 0, 'Override/Implement methods...', 'Override' @@ -1541,6 +1633,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for implementing methods)") void testStrikeOutDeprecatedSuperMethods() { configure() myFixture.assertPreferredCompletionItems 0, 'void foo1', 'void foo2' @@ -1548,9 +1641,12 @@ class XInternalError {} assert LookupElementPresentation.renderElement(lookup.items[1]).strikeout } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for equals() and hashCode())") void testInvokeGenerateEqualsHashCodeOnOverrideCompletion() { doTest() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for 'toString()')") void testInvokeGenerateToStringOnOverrideCompletion() { doTest() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters and setters)") void testAccessorViaCompletion() { configure() @@ -1574,6 +1670,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters and setters)") void testNoSetterForFinalField() { configure() myFixture.assertPreferredCompletionItems 0, 'public', 'public int getFinalField' @@ -1595,10 +1692,12 @@ class XInternalError {} doTest() } + @NeedsIndicesState.StandardLibraryIndices void testMulticaretMethodWithParen() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testMulticaretTyping() { configure() assert lookup @@ -1608,6 +1707,7 @@ class XInternalError {} checkResult() } + @NeedsIndicesState.StandardLibraryIndices void testMulticaretCompletionFromNonPrimaryCaret() { configure() myFixture.assertPreferredCompletionItems(0, "arraycopy") @@ -1617,6 +1717,7 @@ class XInternalError {} doTest '\t' } + @NeedsIndicesState.FullIndices void "test complete lowercase class name"() { myFixture.addClass("package foo; public class myClass {}") myFixture.configureByText "a.java", """ @@ -1629,6 +1730,7 @@ class Foo extends myClass ''' } + @NeedsIndicesState.StandardLibraryIndices void "test don't show static inner class after instance qualifier"() { myFixture.configureByText "a.java", """ class Foo { @@ -1644,6 +1746,7 @@ class Bar { assert !('Inner' in myFixture.lookupElementStrings) } + @NeedsIndicesState.StandardLibraryIndices void "test show static member after instance qualifier when nothing matches"() { myFixture.configureByText "a.java", "class Foo{{ \"\". }}" myFixture.completeBasic() @@ -1656,6 +1759,7 @@ class Bar { void testNoMathTargetMethods() { doAntiTest() } + @NeedsIndicesState.FullIndices void testNoLowercaseClasses() { myFixture.addClass("package foo; public class abcdefgXxx {}") doAntiTest() @@ -1663,11 +1767,13 @@ class Bar { assertStringItems('abcdefgXxx') } + @NeedsIndicesState.FullIndices void testProtectedFieldInAnotherPackage() { myFixture.addClass("package foo; public class Super { protected String myString; }") doTest() } + @NeedsIndicesState.FullIndices void testUnimportedStaticInnerClass() { myFixture.addClass("package foo; public class Super { public static class Inner {} }") doTest() @@ -1675,6 +1781,7 @@ class Bar { void testNoJavaLangPackagesInImport() { doAntiTest() } + @NeedsIndicesState.FullIndices void testNoStaticDuplicatesFromExpectedMemberFactories() { configure() myFixture.complete(CompletionType.BASIC, 2) @@ -1689,6 +1796,7 @@ class Bar { assertNull(getLookup()) } + @NeedsIndicesState.SmartMode(reason = "JavaGenerateMemberCompletionContributor.fillCompletionVariants works in smart mode only (for getters)") void "test code cleanup during completion generation"() { myFixture.configureByText "a.java", "class Foo {int i; ge}" myFixture.enableInspections(new UnqualifiedFieldAccessInspection()) @@ -1709,6 +1817,7 @@ class Bar { assert 'B' == LookupElementPresentation.renderElement(myFixture.lookup.items[0]).typeText } + @NeedsIndicesState.StandardLibraryIndices void testShowMostSpecificOverrideOnlyFromClass() { configure() assert 'Door' == LookupElementPresentation.renderElement(myFixture.lookup.items[0]).typeText @@ -1727,6 +1836,7 @@ class Bar { assert LookupElementPresentation.renderElement(items[3]).tailFragments[0].italic } + @NeedsIndicesState.FullIndices void testShowNonImportedVarInitializers() { configure() myFixture.assertPreferredCompletionItems 1, 'Field', 'FIELD1', 'FIELD2', 'FIELD3', 'FIELD4' @@ -1736,12 +1846,14 @@ class Bar { assert !LookupElementPresentation.renderElement(fieldItems[3]).tailFragments[1].italic } + @NeedsIndicesState.StandardLibraryIndices void testSuggestInterfaceArrayWhenObjectIsExpected() { configure() assert LookupElementPresentation.renderElement(myFixture.lookup.items[0]).tailText.contains('{...}') assert LookupElementPresentation.renderElement(myFixture.lookup.items[1]).tailText.contains('[]') } + @NeedsIndicesState.StandardLibraryIndices void testSuggestInterfaceArrayWhenObjectArrayIsExpected() { configure() assert LookupElementPresentation.renderElement(myFixture.lookup.items[0]).tailText.contains('{...}') @@ -1749,18 +1861,21 @@ class Bar { } void testDispreferPrimitiveTypesInCallArgs() throws Throwable { - CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE) configure() myFixture.assertPreferredCompletionItems 0, "dx", "doo", "Doo", "double" } + @NeedsIndicesState.StandardLibraryIndices void testCopyConstructor() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testGetClassType() { configure() assert 'Class' == LookupElementPresentation.renderElement(myFixture.lookupElements[0]).typeText } + @NeedsIndicesState.FullIndices void testNonImportedClassAfterNew() { def uClass = myFixture.addClass('package foo; public class U {}') myFixture.configureByText('a.java', 'class X {{ new Ux }}') @@ -1771,7 +1886,7 @@ class Bar { void testSuggestClassNamesForLambdaParameterTypes() { doTest('\n') } void testOnlyExtendsSuperInWildcard() { - CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE + CodeInsightSettings.instance.setCompletionCaseSensitive(CodeInsightSettings.NONE) configure() assert myFixture.lookupElementStrings == ['extends', 'super'] @@ -1783,12 +1898,14 @@ class Bar { checkResultByFile(getTestName(false) + ".java") } + @NeedsIndicesState.FullIndices void testChainInLambdaBinary() { codeStyleSettings.ALIGN_MULTILINE_BINARY_OPERATION = true myFixture.addClass("package pkg; public class PathUtil { public static String toSystemDependentName() {} }") doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testPairAngleBracketDisabled() { CodeInsightSettings.instance.AUTOINSERT_PAIR_BRACKET = false doTest('<') @@ -1799,6 +1916,7 @@ class Bar { assert myFixture.lookupElementStrings == ['indexOf'] } + @NeedsIndicesState.StandardLibraryIndices void testDuplicateEnumValueOf() { configure() assert myFixture.lookupElements.collect { LookupElementPresentation.renderElement((LookupElement)it).itemText } == ['Bar.valueOf', 'Foo.valueOf', 'Enum.valueOf'] @@ -1811,6 +1929,7 @@ class Bar { void testNoCallsInPackageStatement() { doAntiTest() } + @NeedsIndicesState.FullIndices void testTypeParameterShadowingClass() { configure() myFixture.assertPreferredCompletionItems 0, 'Tttt', 'Tttt' @@ -1843,21 +1962,28 @@ class Bar {{ void testNoNonAnnotationMethods() { doAntiTest() } + @NeedsIndicesState.StandardLibraryIndices void testPreferBigDecimalToJavaUtilInner() { configure() myFixture.assertPreferredCompletionItems 0, 'BigDecimal', 'BigDecimalLayoutForm' } + @NeedsIndicesState.StandardLibraryIndices void testOnlyExceptionsInMultiCatch1() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyExceptionsInMultiCatch2() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyResourcesInResourceList1() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyResourcesInResourceList2() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyResourcesInResourceList3() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testOnlyResourcesInResourceList4() { doTest('\n') } void testOnlyResourcesInResourceList5() { doTest('\n') } @@ -1866,8 +1992,10 @@ class Bar {{ void testMethodReferenceCallContext() { doTest('\n') } + @NeedsIndicesState.FullIndices void testDestroyingCompletedClassDeclaration() { doTest('\n') } + @NeedsIndicesState.StandardLibraryIndices void testResourceParentInResourceList() { configureByTestName() assert 'MyOuterResource' == myFixture.lookupElementStrings[0] @@ -1888,6 +2016,7 @@ class Bar {{ checkResultByFile(getTestName(false) + "_after.java") } + @NeedsIndicesState.FullIndices void testCompletingClassWithSameNameAsPackage() { myFixture.addClass("package Apple; public class Apple {}") doTest('\n') @@ -1902,6 +2031,7 @@ class Bar {{ checkResult() } + @NeedsIndicesState.FullIndices void testRemoveUnusedImportOfSameName() { myFixture.addClass("package foo; public class List {}") configureByTestName() @@ -1941,6 +2071,7 @@ class Abc { void testSuggestCurrentClassInSecondSuperGenericParameter() { doTest('\n') } + @NeedsIndicesState.FullIndices void "test after new editing prefix back and forth when sometimes there are expected type suggestions and sometimes not"() { myFixture.addClass("class Super {}") myFixture.addClass("class Sub extends Super {}") @@ -1974,6 +2105,7 @@ class Abc { myFixture.checkResult("enum X ex") } + @NeedsIndicesState.FullIndices void testAddImportWhenCompletingInnerAfterNew() { myFixture.addClass("package p; public class Outer { public static class Inner {} }") configureByTestName() @@ -1989,6 +2121,7 @@ class Abc { myFixture.checkResult("class C implements java.util.List") } + @NeedsIndicesState.StandardLibraryIndices void "test suggest Object methods when super is unresolved"() { def checkGetClassPresent = { String text -> myFixture.configureByText("a.java", text) diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SecondSmartTypeCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SecondSmartTypeCompletionTest.java index dd0da9391e0b..005e8a2cc49d 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SecondSmartTypeCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SecondSmartTypeCompletionTest.java @@ -20,6 +20,7 @@ import com.intellij.codeInsight.completion.CompletionType; import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase; import com.intellij.codeInsight.lookup.LookupElementPresentation; import com.intellij.codeInsight.lookup.LookupManager; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.testFramework.PlatformTestUtil; import com.intellij.util.ThrowableRunnable; import com.intellij.util.containers.ContainerUtil; @@ -57,11 +58,15 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas assertStringItems("getBar().getGoo", "getBar().getGoo2"); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestArraysAsList() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestArraysAsListWildcard() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestToArrayWithNewEmptyArray() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestToArrayWithExistingEmptyArray() throws Throwable { configure(); assertStringItems("foos().toArray(EMPTY_ARRAY)", "foos().toArray(EMPTY_ARRAY2)"); @@ -71,11 +76,15 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas public void testToArrayGenericArrayCreation() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testToArrayFieldsQualifier() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testToArrayMethodQualifier() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testToListWithQualifier() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestToArrayWithExistingEmptyArrayFromAnotherClass() throws Throwable { configure(); assertStringItems("foos().toArray(Bar.EMPTY_ARRAY)", "foos().toArray(Bar.EMPTY_ARRAY2)"); @@ -86,12 +95,14 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas public void testNonInitializedField() throws Throwable { doTest(); } public void testIgnoreToString() throws Throwable { doTest(); } public void testDontIgnoreToStringInsideIt() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testDontIgnoreToStringInStringBuilders() throws Throwable { configure(); myFixture.assertPreferredCompletionItems(0, "bar.substring", "bar.substring", "bar.toString"); } public void testNoObjectMethodsAsFirstPart() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testGetClassLoader() throws Throwable { configure(); selectItem(myItems[0]); @@ -125,6 +136,7 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas configureByFile(getTestName(false) + ".java"); } + @NeedsIndicesState.StandardLibraryIndices public void testNoArraysAsListCommonPrefix() throws Throwable { configure(); checkResultByFile(getTestName(false) + ".java"); @@ -144,6 +156,7 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas } public void testDontChainStringMethodsOnString() throws Throwable { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testStringMethodsWhenNothingFound() throws Throwable { doTest(); } public void testDontSuggestTooGenericMethods() throws Throwable { @@ -164,6 +177,7 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas assertStringItems("o.gggg", "false", "true"); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyListInMethodCall() throws Throwable { configure(); selectItem(myItems[0]); @@ -174,12 +188,14 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas checkResultByFile(getTestName(false) + "-out.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testSingletonMap() throws Throwable { configure(); selectItem(myItems[0]); checkResult(); } + @NeedsIndicesState.StandardLibraryIndices public void testChainDuplicationAfterInstanceof() { configure(); assertStringItems("test.test", "toString"); @@ -202,11 +218,13 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas checkResult(); } + @NeedsIndicesState.FullIndices public void testGlobalFactoryMethods() { configure(); assertStringItems("createExpected", "Constants.SUBSTRING", "createSubGeneric", "createSubRaw", "createSubString"); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyMapPresentation() { configure(); LookupElementPresentation presentation = new LookupElementPresentation(); @@ -214,6 +232,7 @@ public class SecondSmartTypeCompletionTest extends LightFixtureCompletionTestCas assertEquals("Collections.emptyMap", presentation.getItemText()); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyMapPresentation2() { configure(); LookupElementPresentation presentation = new LookupElementPresentation(); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SignatureCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SignatureCompletionTest.groovy index c22e02f6fef9..1ce40cbe730d 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SignatureCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SignatureCompletionTest.groovy @@ -9,6 +9,7 @@ import com.intellij.openapi.util.registry.Registry import com.intellij.psi.PsiMethod import com.intellij.psi.statistics.StatisticsManager import com.intellij.psi.statistics.impl.StatisticsManagerImpl +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic /** @@ -51,6 +52,7 @@ class SignatureCompletionTest extends LightFixtureCompletionTestCase { void testNonDefaultConstructor() { doFirstItemTest() } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") void testAnonymousNonDefaultConstructor() { configureByTestName() myFixture.type('\n') diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType14CompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType14CompletionTest.java index e92052b18c6b..4792ceb6c212 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType14CompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType14CompletionTest.java @@ -20,6 +20,7 @@ import com.intellij.codeInsight.completion.CompletionType; import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase; import com.intellij.codeInsight.lookup.Lookup; import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.NeedsIndicesState; import org.jetbrains.annotations.NotNull; public class SmartType14CompletionTest extends LightFixtureCompletionTestCase { @@ -39,6 +40,7 @@ public class SmartType14CompletionTest extends LightFixtureCompletionTestCase { return JAVA_1_4; } + @NeedsIndicesState.StandardLibraryIndices public void testLogger14() { doTest(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType17CompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType17CompletionTest.java index 5a99f399118a..63b61b918415 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType17CompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType17CompletionTest.java @@ -21,6 +21,7 @@ import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase; import com.intellij.codeInsight.lookup.Lookup; import com.intellij.codeInsight.lookup.LookupElementPresentation; import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.NeedsIndicesState; import org.jetbrains.annotations.NotNull; public class SmartType17CompletionTest extends LightFixtureCompletionTestCase { @@ -44,6 +45,7 @@ public class SmartType17CompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testDiamondCollapsedWithMethodTypeParameter() { doTest(); } @@ -56,20 +58,24 @@ public class SmartType17CompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testDiamondNotCollapsedNotApplicable() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testDiamondNotCollapsedInCaseOfAnonymousClasses() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testDiamondNotCollapsedInCaseOfInapplicableInference() { doTest(); } public void testTryWithResourcesNoSemicolon() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testTryWithResourcesThrowsException() { configureByFile("/" + getTestName(false) + ".java"); myFixture.type('\n'); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType18CompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType18CompletionTest.java index 2499494d753a..e4f48fdc5f4b 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType18CompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartType18CompletionTest.java @@ -20,6 +20,7 @@ import com.intellij.codeInsight.completion.CompletionType; import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase; import com.intellij.codeInsight.lookup.Lookup; import com.intellij.testFramework.LightProjectDescriptor; +import com.intellij.testFramework.NeedsIndicesState; import org.jetbrains.annotations.NotNull; public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { @@ -40,6 +41,7 @@ public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { } + @NeedsIndicesState.StandardLibraryIndices public void testExpectedReturnType() { doTest(); } @@ -48,26 +50,32 @@ public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExpectedReturnType1() { doTest(); } - + + @NeedsIndicesState.StandardLibraryIndices public void testSemicolonInExpressionBodyInLocalVariable() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSemicolonInCodeBlocBodyInLocalVariable() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSemicolonInExpressionBodyInExpressionList() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testIgnoreDefaultMethods() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInLambdaPosition() { doTest(); } @@ -76,34 +84,42 @@ public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInLambdaPositionNameSubstitution() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInLambdaPositionSameNames() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInCollectionForEach() { doTest();} public void testConstructorRef() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testInnerArrayConstructorRef() { doTest(true); } + @NeedsIndicesState.StandardLibraryIndices public void testAbstractArrayConstructorRef() { doTest(true); } public void testNoConstraintsWildcard() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") public void testDiamondCollapsedInsideAnonymous() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") public void testDiamondCollapsedInFieldInitializerInsideAnonymous() { doTest(); } + @NeedsIndicesState.FullIndices public void testInheritorConstructorRef() { myFixture.addClass("package intf; public interface Intf {}"); myFixture.addClass("package foo; public class ImplBar implements intf.Intf {}"); @@ -123,14 +139,17 @@ public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testFilteredStaticMethods() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testFilterWrongParamsMethods() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testNoQualifier() { doTest(); } @@ -138,38 +157,44 @@ public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { public void testFilterAmbiguity() { configureByFile("/" + getTestName(false) + ".java"); assertNotNull(myItems); - assertTrue(myItems.length == 0); + assertEquals(0, myItems.length); } public void testNotAvailableInLambdaPositionAfterQualifier() { configureByFile("/" + getTestName(false) + ".java"); assertNotNull(myItems); - assertTrue(myItems.length == 0); + assertEquals(0, myItems.length); } public void testInferFromRawType() { configureByFile("/" + getTestName(false) + ".java"); assertNotNull(myItems); - assertTrue(myItems.length == 0); + assertEquals(0, myItems.length); } public void testDiamondsInsideMethodCall() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testSimpleMethodReference() { doTest(true); } + @NeedsIndicesState.StandardLibraryIndices public void testStaticMethodReference() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testStaticMethodReferenceInContextWithTypeArgs() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testOuterMethodReference() { doTest(true); } public void testNoAnonymousOuterMethodReference() { doAntiTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodReferenceOnAncestor() { doTest(true); } + @NeedsIndicesState.StandardLibraryIndices public void testObjectsNonNull() { doTest(true); } public void testNoLambdaSuggestionForGenericsFunctionalInterfaceMethod() { @@ -177,13 +202,15 @@ public class SmartType18CompletionTest extends LightFixtureCompletionTestCase { assertEmpty(myItems); } -public void testConvertToObjectStream() { + @NeedsIndicesState.StandardLibraryIndices + public void testConvertToObjectStream() { configureByTestName(); myFixture.complete(CompletionType.SMART, 2); - myFixture.type('\n'); + myFixture.type('\n'); checkResultByFile("/" + getTestName(false) + "-out.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testConvertToDoubleStream() { configureByTestName(); myFixture.complete(CompletionType.SMART, 2); @@ -191,12 +218,14 @@ public void testConvertToObjectStream() { checkResultByFile("/" + getTestName(false) + "-out.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testNoUnrelatedMethodSuggestion() { configureByTestName(); myFixture.complete(CompletionType.SMART, 1); assertOrderedEquals(myFixture.getLookupElementStrings(), "this"); } + @NeedsIndicesState.StandardLibraryIndices public void testInferFromReturnTypeWhenCompleteInsideArgList() { configureByTestName(); myFixture.complete(CompletionType.SMART, 1); @@ -210,6 +239,7 @@ public void testConvertToObjectStream() { checkResultByFile("/" + getTestName(false) + "-out.java"); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testInsideNewExpressionWithDiamondAndOverloadConstructors() { configureByTestName(); myFixture.complete(CompletionType.SMART, 1); @@ -217,11 +247,14 @@ public void testConvertToObjectStream() { checkResultByFile("/" + getTestName(false) + "-out.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testCollectorsToList() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testCollectionsEmptyMap() { doTest(true); } + @NeedsIndicesState.StandardLibraryIndices public void testExpectedSuperOfLowerBound() { doTest(false); } @@ -246,55 +279,68 @@ public void testConvertToObjectStream() { checkResultByFile("/" + getTestName(false) + "-out.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testOnlyCompatibleTypes() { configureByTestName(); assertOrderedEquals(myFixture.getLookupElementStrings(), "get2"); } + @NeedsIndicesState.StandardLibraryIndices public void testInferredObjects() { configureByTestName(); assertOrderedEquals(myFixture.getLookupElementStrings(), "M", "HM"); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestMapInheritors() { doTest(); } public void testUnboundTypeArgs() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCallBeforeLambda() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testMapGetOrDefault() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "TimeUnit.DAYS"); } + @NeedsIndicesState.StandardLibraryIndices public void testFreeGenericsAfterClassLiteral() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "String.class", "tryCast"); } + @NeedsIndicesState.StandardLibraryIndices public void testNewHashMapTypeArguments() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testNewMapTypeArguments() { doTest(false); } + @NeedsIndicesState.StandardLibraryIndices public void testPreferLambdaOverGenericGetter() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "s -> ", "isEmpty", "isNull", "nonNull", "getSomeGenericValue"); } + @NeedsIndicesState.StandardLibraryIndices public void testNoInaccessibleConstructorRef() { configureByTestName(); assertOrderedEquals(myFixture.getLookupElementStrings(), "() -> "); } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") public void testPreselectTreeMapWhenSortedMapExpected() { configureByTestName(); myFixture.assertPreferredCompletionItems(2, "SortedMap", "NavigableMap", "TreeMap", "ConcurrentNavigableMap", "ConcurrentSkipListMap"); } + @NeedsIndicesState.StandardLibraryIndices public void testConsiderClassProximityForClassLiterals() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "String.class"); } + @NeedsIndicesState.StandardLibraryIndices public void testNestedCollectorsCounting() { doTest(false); } public void testFilterInaccessibleConstructors() { doAntiTest(); } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionDfaTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionDfaTest.groovy index f22a8d62bea4..9d0bcda9f909 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionDfaTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionDfaTest.groovy @@ -17,6 +17,7 @@ package com.intellij.java.codeInsight.completion import com.intellij.JavaTestUtil import com.intellij.codeInsight.completion.CompletionType import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic /** @@ -43,8 +44,10 @@ class SmartTypeCompletionDfaTest extends LightFixtureCompletionTestCase { checkResultByFile("/" + getTestName(false) + "-out.java") } + @NeedsIndicesState.FullIndices void testCastGenericQualifier() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testDontAutoCastWhenAlreadyCasted() { configureByTestName() myFixture.assertPreferredCompletionItems(0, "s", "toString") @@ -52,22 +55,28 @@ class SmartTypeCompletionDfaTest extends LightFixtureCompletionTestCase { checkResultByTestName() } + @NeedsIndicesState.StandardLibraryIndices void testAutoCastWhenAlreadyCasted() { configureByTestName() myFixture.type('\n') checkResultByTestName() } + @NeedsIndicesState.StandardLibraryIndices void testSuggestCastedValueAfterCast() { doTest() } + @NeedsIndicesState.FullIndices void testSuggestInstanceofedValue() { doTest() } void testSuggestInstanceofedValueInTernary() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testSuggestInstanceofedValueInComplexIf() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testSuggestInstanceofedValueInElseNegated() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testSuggestInstanceofedValueAfterReturn() { doTest() } void testNoInstanceofedValueWhenBasicSuits() { doTest() } @@ -80,6 +89,7 @@ class SmartTypeCompletionDfaTest extends LightFixtureCompletionTestCase { void testInstanceofedInsideAnonymous() { doTest() } + @NeedsIndicesState.StandardLibraryIndices void testCastToTypeWithWildcard() { doTest() } } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionOrderingTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionOrderingTest.groovy index 27a638bbf15d..7a62644692b0 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionOrderingTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionOrderingTest.groovy @@ -25,6 +25,7 @@ import com.intellij.codeInsight.lookup.impl.LookupImpl import com.intellij.openapi.fileEditor.FileDocumentManager import com.intellij.psi.PsiClass import com.intellij.psi.statistics.StatisticsManager +import com.intellij.testFramework.NeedsIndicesState class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { private static final String BASE_PATH = "/codeInsight/completion/smartTypeSorting" @@ -33,15 +34,18 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { super(CompletionType.SMART) } + @NeedsIndicesState.StandardLibraryIndices void testJComponentAdd() throws Throwable { checkPreferredItems(0, "name", "b", "fooBean239", "foo") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testJComponentAddNew() throws Throwable { //there's no PopupMenu in mock jdk checkPreferredItems(2, "Component", "String", "FooBean3", "JComponent", "Container") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testJComponentAddNewWithStats() throws Throwable { //there's no PopupMenu in mock jdk final LookupImpl lookup = invokeCompletion("/JComponentAddNew.java") @@ -56,6 +60,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(2, "Component", "String", "Container", "FooBean3", "JComponent") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testNewListAlwaysFirst() { def lookup = invokeCompletion(getTestName(false) + ".java") assertPreferredItems 1, 'List', 'ArrayList', 'AbstractList', 'AbstractSequentialList' @@ -66,6 +71,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems 1, 'List', 'AbstractSequentialList', 'ArrayList', 'AbstractList' } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testNoStatsOnUnsuccessfulAttempt() { final LookupImpl lookup = invokeCompletion("/JComponentAddNew.java") assertPreferredItems(2, "Component", "String", "FooBean3", "JComponent", "Container") @@ -84,26 +90,32 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "goo", "bar", "foo") } + @NeedsIndicesState.FullIndices void testNewRunnable() throws Throwable { checkPreferredItems(0, "Runnable", "MyAnotherRunnable", "MyRunnable", "Thread") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testNewComponent() throws Throwable { checkPreferredItems(1, "Component", "Foo", "JComponent", "Container") } + @NeedsIndicesState.StandardLibraryIndices void testClassLiteral() throws Throwable { checkPreferredItems(0, "String.class") } + @NeedsIndicesState.StandardLibraryIndices void testMethodsWithSubstitutableReturnType() throws Throwable { checkPreferredItems(0, "foo", "toString", "bar") } + @NeedsIndicesState.StandardLibraryIndices void testDontPreferKeywords() throws Throwable { checkPreferredItems(0, "o1", "foo", "name", "this") } + @NeedsIndicesState.StandardLibraryIndices void testEnumValueOf() throws Throwable { checkPreferredItems(0, "e", "MyEnum.BAR", "MyEnum.FOO", "valueOf", "valueOf") } @@ -116,48 +128,59 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "getVersionString", "getTitle") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testPreferImportedClasses() throws Throwable { //there's no PopupMenu in mock jdk checkPreferredItems(2, "Component", "String", "FooBean3", "JPanel", "JComponent") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testPreferNestedClasses() throws Throwable { //there's no PopupMenu in mock jdk checkPreferredItems(2, "Component", "String", "FooBean3", "NestedClass", "JComponent") } + @NeedsIndicesState.StandardLibraryIndices void testSmartCollections() throws Throwable { checkPreferredItems(0, "s") } + @NeedsIndicesState.StandardLibraryIndices void testSmartEquals() throws Throwable { checkPreferredItems(0, "s") } + @NeedsIndicesState.StandardLibraryIndices void testSmartEquals2() throws Throwable { checkPreferredItems(0, "foo", "this", "o", "s") } + @NeedsIndicesState.StandardLibraryIndices void testSmartEquals3() throws Throwable { checkPreferredItems(0, "b", "this", "a", "z") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testSmartCollectionsNew() throws Throwable { checkPreferredItems(1, "Foo", "Bar") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testSmartEqualsNew() throws Throwable { checkPreferredItems(1, "Foo", "Bar") } + @NeedsIndicesState.StandardLibraryIndices void testSmartEqualsNew2() throws Throwable { checkPreferredItems(0, "Foo") } + @NeedsIndicesState.StandardLibraryIndices void testBooleanValueOf() throws Throwable { checkPreferredItems(0, "b", "Boolean.FALSE", "Boolean.TRUE", "equals", "false", "true", "valueOf", "valueOf") } + @NeedsIndicesState.StandardLibraryIndices void testXmlTagGetAttribute() throws Throwable { checkPreferredItems(0, "getAttributeValue", "getNamespace", "toString") } @@ -178,6 +201,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "MyProcessor", "Proc1") } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") void testStatisticsAffectsNonPreferableExpectedItems() throws Throwable { final LookupImpl lookup = invokeCompletion(getTestName(false) + ".java") assertPreferredItems(1, "List", "ArrayList", "AbstractList", "AbstractSequentialList") @@ -187,6 +211,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "List", "ArrayList", "AbstractList", "AbstractSequentialList") } + @NeedsIndicesState.StandardLibraryIndices void testPreferNonRecursiveMethodParams() throws Throwable { checkPreferredItems(0, "b", "s", "a", "hashCode") } @@ -223,18 +248,22 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "Foo", "Bar", "Goo") } + @NeedsIndicesState.StandardLibraryIndices void testLiteralInReturn() throws Throwable { checkPreferredItems(0, "false", "true", "equals") } + @NeedsIndicesState.StandardLibraryIndices void testLiteralInIf() throws Throwable { checkPreferredItems(0, "equals", "false", "true") } + @NeedsIndicesState.StandardLibraryIndices void testFactoryMethodForDefaultType() throws Throwable { checkPreferredItems(0, "create", "this") } + @NeedsIndicesState.StandardLibraryIndices void testLocalVarsBeforeClassLiterals() throws Throwable { checkPreferredItems(0, "local", "Foo.class", "Bar.class") } @@ -243,6 +272,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems(0, "_o", "b") } + @NeedsIndicesState.FullIndices void testInnerClassesProximity() throws Throwable { checkPreferredItems(0, "Goo", "InnerGoo", "Bar", "AGoo") } @@ -259,6 +289,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "foo", "param", "this", "goo", "bar") } + @NeedsIndicesState.StandardLibraryIndices void testPreferredByNameDontChangeStatistics() throws Throwable { invokeCompletion(getTestName(false) + ".java") assertPreferredItems(0, "foo", "false") @@ -274,10 +305,12 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "myBar", "myFoo") } + @NeedsIndicesState.StandardLibraryIndices void testPreferSameNamedMethods() { checkPreferredItems(0, "foo", "boo", "doo", "hashCode") } + @NeedsIndicesState.FullIndices void testErasureNotAffectingProximity() { myFixture.addClass("package foo; public interface Foo {}") myFixture.addClass("package bar; public class Bar implements foo.Foo {}") @@ -298,11 +331,13 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertEquals("Bar", presentation.getItemText()) } + @NeedsIndicesState.FullIndices void testAssertEquals() throws Throwable { myFixture.addClass("package junit.framework; public class Assert { public static void assertEquals(Object a, Object b) {} }") checkPreferredItems(0, "boo", "bar") } + @NeedsIndicesState.FullIndices void testPreferCollectionsEmptyList() throws Throwable { myFixture.addClass("package foo; public class FList implements java.util.List { public static FList emptyList() {} }") configureNoCompletion(getTestName(false) + ".java") @@ -311,10 +346,12 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems(0, "local", "local.subList", "locMethod") } + @NeedsIndicesState.StandardLibraryIndices void testDispreferGetterInSetterCall() { checkPreferredItems 0, 'color', 'getZooColor', 'getColor', 'hashCode' } + @NeedsIndicesState.StandardLibraryIndices void testPreferOtherGetterInSetterCall() { checkPreferredItems 0, 'color', 'getColor', 'getZooColor', 'hashCode' } @@ -323,30 +360,37 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { checkPreferredItems 0, 'e', 'createEvent' } + @NeedsIndicesState.StandardLibraryIndices void testPreferLocalOverThis() { checkPreferredItems 0, 'value', 'this', 'hashCode' } + @NeedsIndicesState.StandardLibraryIndices void testGetLogger() { checkPreferredItems 0, 'Foo.class', 'forName' } + @NeedsIndicesState.StandardLibraryIndices void testGetWildcardLogger() { checkPreferredItems 0, 'Foo.class', 'forName' } + @NeedsIndicesState.StandardLibraryIndices void testGetWildcardFactoryLogger() { checkPreferredItems 0, 'Foo.class', 'forName' } + @NeedsIndicesState.StandardLibraryIndices void testPreferLocalWildcardClassOverObject() { checkPreferredItems 0, 'type', 'Object.class', 'forName', 'forName' } + @NeedsIndicesState.StandardLibraryIndices void testPreferStringsInStringConcatenation() { checkPreferredItems 0, 'toString' } + @NeedsIndicesState.FullIndices void testGlobalStaticMemberStats() { configureNoCompletion(getTestName(false) + ".java") myFixture.complete(CompletionType.SMART, 2) @@ -355,6 +399,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assertPreferredItems 0, 'newLinkedSet1', 'newLinkedSet0', 'newLinkedSet2' } + @NeedsIndicesState.FullIndices void testPreferExpectedTypeMembers() { configureNoCompletion(getTestName(false) + ".java") myFixture.complete(CompletionType.SMART, 2) @@ -362,6 +407,7 @@ class SmartTypeCompletionOrderingTest extends CompletionSortingTestCase { assert lookup.items.size() == 2 } + @NeedsIndicesState.FullIndices void testPreferGlobalMembersReturningExpectedType() { configureNoCompletion(getTestName(false) + ".java") def items = myFixture.complete(CompletionType.SMART, 2) diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java index af22da9f8efa..e9bba5385c58 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/SmartTypeCompletionTest.java @@ -22,6 +22,7 @@ import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.util.PsiUtil; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.testFramework.fixtures.CodeInsightTestUtil; import com.intellij.util.containers.ContainerUtil; @@ -47,6 +48,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } + @NeedsIndicesState.StandardLibraryIndices public void testParenAfterCast3() { String path = "/parenAfterCast"; @@ -150,6 +152,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after3.java"); } + @NeedsIndicesState.FullIndices public void testAfterNew4() { String path = "/afterNew"; @@ -158,6 +161,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after4.java"); } + @NeedsIndicesState.FullIndices public void testAfterNew5() { String path = "/afterNew"; @@ -166,6 +170,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after5.java"); } + @NeedsIndicesState.FullIndices public void testAfterNew6() { String path = "/afterNew"; @@ -174,6 +179,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after6.java"); } + @NeedsIndicesState.FullIndices public void testAfterNew7() { String path = "/afterNew"; @@ -182,6 +188,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after7.java"); } + @NeedsIndicesState.FullIndices public void testAfterNew8() { String path = "/afterNew"; @@ -190,6 +197,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after8.java"); } + @NeedsIndicesState.FullIndices public void testAfterNew9() { String path = "/afterNew"; @@ -214,6 +222,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after13.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testAfterThrowNew1() { String path = "/afterNew"; @@ -222,6 +231,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after14.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testAfterThrowNew2() { String path = "/afterNew"; @@ -230,6 +240,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after15.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testAfterThrowNew3() { String path = "/afterNew"; @@ -239,6 +250,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } public void testCastInThrow() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNonExistentGenericAfterNew() { doTest('\n'); } public void testParenAfterNewWithinInnerExpr() { @@ -313,6 +325,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after5.java"); } + @NeedsIndicesState.FullIndices public void testAfterInstanceOf1() { String path = "/afterInstanceOf"; @@ -320,6 +333,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after1.java"); } + @NeedsIndicesState.FullIndices public void testAfterInstanceOf2() { String path = "/afterInstanceOf"; @@ -327,8 +341,11 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(path + "/after2.java"); } + @NeedsIndicesState.StandardLibraryIndices public void testInsideCatch() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInsideCatchFinal() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInsideCatchWithoutThrow() { doTest(); } public void testGenerics6() { @@ -388,28 +405,36 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertEquals(2, myItems.length); } + @NeedsIndicesState.StandardLibraryIndices public void testCollectionsEmptySetInMethodCall() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCollectionsEmptySetInTernary() { doTest(); } public void testStringConstantInAnno() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCollectionsEmptySetInTernary2() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testConstructorOnSeparateLineInMethodCall() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testConstructorWithExistingParens() { doTest(); } public void testMethodAnnotationNamedParameter() { doTest(); } public void testInheritedClass() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testClassLiteralInAnno1() { doTest(); } public void testMeaninglessExplicitWildcardParam() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExplicitWildcardArrayParam() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCatchInAnonymous() { doTest(); } public void testThrowRuntimeException() { doTest(); } @@ -422,8 +447,10 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testQualifiedThisInAnonymousConstructor() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExceptionTwice() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExceptionTwice2() { doTest(); } public void testNewInnerRunnable() { doTest(); } @@ -434,6 +461,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testJavadocThrows() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodThrows() { doTest(); } public void testDoNotExcludeAssignedVariable() { doTest(); } @@ -443,25 +471,32 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testPrivateOverloads() { doTest(); } public void testInaccessibleMethodArgument() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testPolyadicExpression() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCastAutoboxing() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCastAutoboxing2() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCastAutoboxing3() { doItemTest(); } public void testCastWildcards() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoSecondMethodTypeArguments() { doTest(Lookup.REPLACE_SELECT_CHAR); } public void testNoFieldsInSuperConstructorCall() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testChainMethodsInSuperConstructorCall() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoUninitializedFieldsInConstructor() { configureByTestName(); assertStringItems("aac", "aab", "hashCode"); @@ -488,6 +523,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByTestName(); } + @NeedsIndicesState.StandardLibraryIndices public void testVoidExpectedType() { configureByTestName(); assertStringItems("notify", "notifyAll", "wait", "wait", "wait", "equals", "hashCode", "toString", "getClass"); @@ -523,10 +559,12 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testSameNamedFieldAndLocal() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoTailWhenNoPairBracket() { doTestNoPairBracket(Lookup.NORMAL_SELECT_CHAR); } public void testNoTailWhenNoPairBracket2() { doTestNoPairBracket(Lookup.NORMAL_SELECT_CHAR); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testAnonymousNoPairBracket() { doTestNoPairBracket(Lookup.NORMAL_SELECT_CHAR); } private void doTestNoPairBracket(final char c) { @@ -540,8 +578,10 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } } + @NeedsIndicesState.StandardLibraryIndices public void testNoConstructorTailWhenNoPairBracket() { doTestNoPairBracket(Lookup.NORMAL_SELECT_CHAR); } + @NeedsIndicesState.StandardLibraryIndices public void testConstructorNoPairBracketSemicolon() { doTestNoPairBracket(';'); } public void testMethodNoPairBracketComma() { doTestNoPairBracket(','); } @@ -553,6 +593,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testConstantTwice() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testConstantTwice2() { configureByTestName(); assertEquals(2, myItems.length); @@ -576,6 +617,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testExclamationMethodFinish() { doTest('!'); } public void testExclamationVariableFinish() { doTest('!'); } + @NeedsIndicesState.StandardLibraryIndices public void testExclamationStaticFieldFinish() { doTest('!'); } public void testExclamationFinishNonBoolean() { doTest('!'); } @@ -589,6 +631,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testBeforeBinaryExpressionInMethodCall() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testAssignableToAfterCast() { doTest(); } public void testInstanceMethodParametersFromStaticContext() { doTest(); } @@ -601,6 +644,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testVoidCast() { doAntiTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoGenericMethodAutoInsertion() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "valueOf"); @@ -610,8 +654,10 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testIntPlusLongNotDouble() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNestedAssignments() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") public void testAfterNewInTernary() { doTest(); } public void testSuggestAnythingWhenWildcardExpected() { @@ -627,6 +673,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertEquals("[]{...} (default package)", LookupElementPresentation.renderElement(myItems[2]).getTailText()); } + @NeedsIndicesState.StandardLibraryIndices public void testNewVararg2() { configureByTestName(); assertStringItems("String", "String", "String"); @@ -652,8 +699,10 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testDefaultAnnoParam() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNewWithTypeParameterErasure() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEverythingDoubles() { configureByTestName(); assertStringItems("hashCode", "indexOf", "lastIndexOf", "size"); @@ -692,8 +741,10 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testDefaultAnnoMethodValue() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testNewAnonymousFunction() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testNewRunnableInsideMethod() { CommonCodeStyleSettings settings = getCodeStyleSettings(); boolean lParenOnNextLine = settings.CALL_PARAMETERS_LPAREN_ON_NEXT_LINE; @@ -705,6 +756,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testNewRunnableInsideMethodMultiParams() { CommonCodeStyleSettings settings = getCodeStyleSettings(); boolean lParenOnNextLine = settings.CALL_PARAMETERS_LPAREN_ON_NEXT_LINE; @@ -720,6 +772,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } public void testUseIntConstantsFromTargetClass() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testUseObjectConstantsFromTargetClass() { doTest(); } public void testUseIntConstantsFromTargetClassReturnValue() { doTest(); } public void testUseIntConstantsFromConstructedClass() { doTest(); } @@ -731,6 +784,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoSemicolonInsideParentheses() { doTest(); } public void testAssignFromTheSameFieldOfAnotherObject() { @@ -759,6 +813,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testCastToArray() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testCommaDoublePenetration() { doFirstItemTest(','); } @@ -818,11 +873,13 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByTestName(); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestTypeParametersInTypeArgumentList() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "T", "String"); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testWrongAnonymous() { configureByTestName(); select(); @@ -833,6 +890,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doActionTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testClassLiteral() { doActionTest(); assertStringItems("String.class"); @@ -846,39 +904,49 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertInstanceOf(item.getPsiElement(), PsiClass.class); } + @NeedsIndicesState.StandardLibraryIndices public void testNoClassLiteral() { doActionTest(); assertStringItems("Object.class", "getClass", "forName", "forName"); } + @NeedsIndicesState.StandardLibraryIndices public void testClassLiteralInAnno2() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testClassLiteralInheritors() { doItemTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testInsertOverride() { JavaCodeStyleSettings styleSettings = JavaCodeStyleSettings.getInstance(getProject()); styleSettings.INSERT_OVERRIDE_ANNOTATION = true; doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testForeach() { doActionTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testIDEADEV2626() { doItemTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testDontSuggestWildcardGenerics() { doItemTest(); } public void testCastWith2TypeParameters() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testClassLiteralInArrayAnnoInitializer() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testClassLiteralInArrayAnnoInitializer2() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testAnnotation() { configureByTestName(); assertStringItems("ElementType.ANNOTATION_TYPE", "ElementType.CONSTRUCTOR", @@ -887,10 +955,12 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { "ElementType.TYPE" /*, "ElementType.TYPE_PARAMETER", "ElementType.TYPE_USE"*/); } + @NeedsIndicesState.StandardLibraryIndices public void testAnnotation2() { configureByTestName(); assertStringItems("RetentionPolicy.CLASS", "RetentionPolicy.RUNTIME", "RetentionPolicy.SOURCE"); } + @NeedsIndicesState.StandardLibraryIndices public void testAnnotation2_2() { configureByTestName(); assertSameElements(myFixture.getLookupElementStrings(), "RetentionPolicy.CLASS", "RetentionPolicy.SOURCE", "RetentionPolicy.RUNTIME"); @@ -918,6 +988,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertStringItems("CONNECTION", "NO_CONNECTION"); } + @NeedsIndicesState.StandardLibraryIndices public void testAnnotation6() { configureByTestName(); @@ -931,6 +1002,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testIDEADEV5150() { doTest('\n'); } @@ -943,11 +1015,14 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testTypeArgs2() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testTypeArgsOverwrite() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testIfConditionExpectedType() { doTest(); } public void testUnboundTypeArgs() { doTest(); } @@ -959,6 +1034,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } public void testExcessiveTail() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testSeveralTypeArguments() { doTest(); } public void testSeveralTypeArgumentsSomeUnknown() { doTest(); } @@ -970,8 +1046,10 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doFirstItemTest(Lookup.REPLACE_SELECT_CHAR); } + @NeedsIndicesState.StandardLibraryIndices public void testConstructorArgsSmartEnter() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR); } + @NeedsIndicesState.StandardLibraryIndices public void testIDEADEV13148() { configureByFile("/IDEADEV13148.java"); assertStringItems("false", "true"); //todo don't suggest boolean literals in synchronized @@ -986,32 +1064,41 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoCommaBeforeVarargs() { doTest(); } public void testEnumField() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEnumField1() { configureByTestName(); checkResultByTestName(); assertEquals(4, myItems.length); } + @NeedsIndicesState.StandardLibraryIndices public void testInsertTypeParametersOnImporting() { doTest('\n'); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyListInReturn() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyListInReturn2() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyListInReturnTernary() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyListBeforeSemicolon() { doItemTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEmptyListWithCollectionsPrefix() { doItemTest(); } public void testForeachLoopVariableInIterableExpression() { doAntiTest(); } + @NeedsIndicesState.FullIndices public void testStaticallyImportedMagicMethod() { configureByTestName(); assertStringItems("foo"); @@ -1021,21 +1108,29 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void _testCallVarargArgument() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testTabToReplaceClassKeyword() { configureByTestName(); selectItem(myItems[0], Lookup.REPLACE_SELECT_CHAR); checkResultByTestName(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoTypeParametersForToArray() { doTest(); } + @NeedsIndicesState.FullIndices public void testStaticallyImportedField() { doTest('\n'); } + @NeedsIndicesState.FullIndices public void testSiblingOfAStaticallyImportedField() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testPrimitiveArrayClassInMethod() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testPrimitiveClassInAnno() { doTest(); } + @NeedsIndicesState.FullIndices public void testNewInnerClassOfSuper() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testAssertThatMatcher() { doTest(); } public void testInferFromCall() { @@ -1080,12 +1175,15 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { "}}"); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testNewAbstractInsideAnonymous() { doTest(); } public void testFilterPrivateConstructors() { doAntiTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExplicitMethodTypeParametersQualify() { doTest(); } public void testExplicitMethodTypeParametersOverZealous() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExplicitMethodTypeParametersFromSuperClass() { doTest(); } public void testWildcardedInstanceof() { doTest(); } @@ -1106,6 +1204,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertStringItems("Bar", "Goo"); } + @NeedsIndicesState.SmartMode(reason = "AbstractExpectedTypeSkipper works in smart mode only") public void testAutoImportExpectedType() { boolean old = CodeInsightSettings.getInstance().ADD_UNAMBIGIOUS_IMPORTS_ON_THE_FLY; CodeInsightSettings.getInstance().ADD_UNAMBIGIOUS_IMPORTS_ON_THE_FLY = true; @@ -1119,25 +1218,32 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { } } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testNoWrongSubstitutorFromStats() { doTest(); FileDocumentManager.getInstance().saveDocument(myFixture.getEditor().getDocument()); doTest(); // stats are changed now } + @NeedsIndicesState.StandardLibraryIndices public void testCommonPrefixWithSelection() { doItemTest(); } + @NeedsIndicesState.SmartMode(reason = "For now ConstructorInsertHandler.createOverrideRunnable doesn't work in dumb mode") public void testNewAbstractClassWithConstructorArgs() { doItemTest(); } public void testArrayInitializerBeforeVarargs() { doTest(); } + @NeedsIndicesState.FullIndices public void testDuplicateMembersFromSuperClass() { doTest(); } public void testInnerAfterNew() { doTest(); } + @NeedsIndicesState.FullIndices public void testOuterAfterNew() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testEverythingInStringConcatenation() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testGetClassWhenClassExpected() { doTest(); } public void testMemberImportStatically() { @@ -1156,11 +1262,13 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertStringItems("Foo"); } + @NeedsIndicesState.FullIndices public void testDuplicateMembersFromSuperClassInAnotherFile() { myFixture.addClass("class Super { public static final Super FOO = null; }"); doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testInsideGenericClassLiteral() { configureByTestName(); assertStringItems("String.class", "StringBuffer.class", "StringBuilder.class"); @@ -1170,6 +1278,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { doActionTest(); } + @NeedsIndicesState.FullIndices public void testInnerClassImports() { JavaCodeStyleSettings settings = JavaCodeStyleSettings.getInstance(getProject()); settings.INSERT_INNER_CLASS_IMPORTS = true; @@ -1189,20 +1298,24 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByTestName(); } + @NeedsIndicesState.FullIndices public void testQualifiedAfterNew() { myFixture.addClass("package foo; public interface Foo {}"); myFixture.addClass("package bar; public class Bar implements foo.Foo {}"); doTest(); } + @NeedsIndicesState.FullIndices public void testAfterQualifiedNew() { myFixture.addClass("class Aa { public class B { } }"); doTest(); } + @NeedsIndicesState.FullIndices public void testTabAfterNew() { doFirstItemTest('\t'); } + @NeedsIndicesState.StandardLibraryIndices public void testSuggestMethodReturnType() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "Serializable", "CharSequence", "Object"); @@ -1213,12 +1326,14 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { assertOrderedEquals(myFixture.getLookupElementStrings(), "Object"); } + @NeedsIndicesState.FullIndices public void testSuggestCastReturnTypeByCalledMethod() { doTest(); } public void testOnlyInterfacesInImplements() { doTest(); } public void testNonStaticField() { doAntiTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testLocalClassInExpectedTypeArguments() { doTest(); } private void doActionTest() { @@ -1288,6 +1403,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { return CodeStyleSettingsManager.getSettings(getProject()).getCommonSettings(JavaLanguage.INSTANCE); } + @NeedsIndicesState.StandardLibraryIndices(reason = "On empty indices 'get2' is filtered out by unmatching type in ReferenceExpressionCompletionContributor.addSmartReferenceSuggestions") public void testOnlyCompatibleTypes() { configureByTestName(); assertOrderedEquals(myFixture.getLookupElementStrings(), "get2"); @@ -1295,6 +1411,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testQualifyOuterClassCall() { doActionTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testExpressionSubtypesInCast() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "String", "StringBuffer", "StringBuilder"); @@ -1302,6 +1419,7 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { public void testStaticBuilder() { doTest(); } public void testStaticBuilderWithArguments() { doTest(); } + @NeedsIndicesState.FullIndices public void testStaticBuilderWithInterfaceAndGenerics() { doTest(); } public void testStaticBuilderWithGenerics() { @@ -1311,20 +1429,26 @@ public class SmartTypeCompletionTest extends LightFixtureCompletionTestCase { checkResultByTestName(); } + @NeedsIndicesState.StandardLibraryIndices public void testFreeGenericsAfterClassLiteral() { configureByTestName(); myFixture.assertPreferredCompletionItems(0, "String.class", "tryCast"); } + @NeedsIndicesState.StandardLibraryIndices public void testNewHashMapTypeArguments() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNewMapTypeArguments() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNewMapObjectTypeArguments() { doTest(); } + @NeedsIndicesState.StandardLibraryIndices public void testNoUnrelatedMethodSuggestion() { configureByTestName(); assertOrderedEquals(myFixture.getLookupElementStrings(), "this"); } + @NeedsIndicesState.FullIndices public void testLog4jLevel() { myFixture.addClass("package org.apache.log4j; " + "public class Category { " + diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/TabCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/TabCompletionTest.java index 23436981f02c..f61201ed53a9 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/TabCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/TabCompletionTest.java @@ -17,6 +17,7 @@ package com.intellij.java.codeInsight.completion; import com.intellij.JavaTestUtil; import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase; +import com.intellij.testFramework.NeedsIndicesState; public class TabCompletionTest extends LightFixtureCompletionTestCase { @Override @@ -34,16 +35,19 @@ public class TabCompletionTest extends LightFixtureCompletionTestCase { checkResultJava(); } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for txt, properties and xml") public void testTabInXml() { configureByFile("TabInXml.xml"); checkResultByFile("TabInXml_After.xml"); } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for txt, properties and xml") public void testTabInXml2() { configureByFile("TabInXml2.xml"); checkResultByFile("TabInXml2_After.xml"); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodCallBeforeAnnotation() { myFixture.configureByFile("MethodCallBeforeAnnotation.java"); myFixture.completeBasic(); @@ -51,6 +55,7 @@ public class TabCompletionTest extends LightFixtureCompletionTestCase { checkResultJava(); } + @NeedsIndicesState.StandardLibraryIndices public void testMethodCallBeforeAnnotation2() { myFixture.configureByFile("MethodCallBeforeAnnotation2.java"); myFixture.completeBasic(); @@ -58,6 +63,7 @@ public class TabCompletionTest extends LightFixtureCompletionTestCase { checkResultJava(); } + @NeedsIndicesState.StandardLibraryIndices public void testReplaceStringLiteral() { configureByTestName(); checkResultJava(); diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy index 216f3b6dcf1d..26f52342f003 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/VariablesCompletionTest.groovy @@ -19,6 +19,7 @@ import com.intellij.JavaTestUtil import com.intellij.codeInsight.completion.LightFixtureCompletionTestCase import com.intellij.ide.highlighter.JavaFileType import com.intellij.psi.codeStyle.JavaCodeStyleSettings +import com.intellij.testFramework.NeedsIndicesState import groovy.transform.CompileStatic @CompileStatic @@ -40,6 +41,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(FILE_PREFIX + "locals/" + getTestName(false) + "_after.java") } + @NeedsIndicesState.FullIndices void testInputMethodEventVariable() throws Exception { myFixture.addClass("package java.awt.event; public interface InputMethodEvent {}") @@ -47,6 +49,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { checkResultByFile(FILE_PREFIX + "locals/" + getTestName(false) + "_after.java") } + @NeedsIndicesState.StandardLibraryIndices void testLocals1() throws Exception { doSelectTest("TestSource1.java", "TestResult1.java") } @@ -66,6 +69,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { doTest("TestSource3.java", "TestResult3.java") } + @NeedsIndicesState.StandardLibraryIndices void testLocals4() throws Exception { doSelectTest("TestSource4.java", "TestResult4.java") } @@ -115,6 +119,7 @@ class VariablesCompletionTest extends LightFixtureCompletionTestCase { doTest("TestSource8.java", "TestResult8.java") } + @NeedsIndicesState.StandardLibraryIndices(reason = "With empty indices 'Object' may be considered variable name, and instanceof is ok here; Object is not resolved thus not replaced with 'o'") void testUnresolvedReference() throws Exception { configureByFile(FILE_PREFIX + "locals/" + getTestName(false) + ".java") assertStringItems("o", "psiClass") @@ -203,6 +208,7 @@ class Foo { myFixture.assertPreferredCompletionItems 0, 'total' } + @NeedsIndicesState.StandardLibraryIndices(reason = "On empty indices String is not resolved and replaced with name 's', filtered out in JavaMemberNameCompletionContributor.getOverlappedNameVersions for being short") void testInitializerMatters() throws Exception { myFixture.configureByText(JavaFileType.INSTANCE, "class Foo {{ String fx = getFoo(); }; String getFoo() {}; }") complete() @@ -244,11 +250,13 @@ class Foo { checkResultByFile(FILE_PREFIX + getTestName(false) + "_after.java") } + @NeedsIndicesState.StandardLibraryIndices(reason = "On empty indices String is not resolved and replaced with name 's', filtered out in JavaMemberNameCompletionContributor.getOverlappedNameVersions for being short") void testConstructorParameterName() { configure() assertStringItems("color") } + @NeedsIndicesState.StandardLibraryIndices(reason = "On empty indices String is not resolved and replaced with name 's', filtered out in JavaMemberNameCompletionContributor.getOverlappedNameVersions for being short; P is from PARAMETER_NAME_PREFIX") void testConstructorParameterNameWithPrefix() { JavaCodeStyleSettings settings = JavaCodeStyleSettings.getInstance(getProject()) settings.FIELD_NAME_PREFIX = "my" @@ -298,6 +306,7 @@ class Rectangle2D { myFixture.assertPreferredCompletionItems 0, 'aDouble', 'rectangle2D' } + @NeedsIndicesState.StandardLibraryIndices void "test suggest field-shadowing parameter name"() { myFixture.configureByText 'a.java', ''' class FooFoo { diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/WordCompletionTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/WordCompletionTest.java index 3085f3ff381e..af4d14c2f94f 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/WordCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/completion/WordCompletionTest.java @@ -21,6 +21,7 @@ import com.intellij.patterns.PlatformPatterns; import com.intellij.psi.*; import com.intellij.psi.impl.source.resolve.reference.PsiReferenceRegistrarImpl; import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.util.ProcessingContext; import org.jetbrains.annotations.NotNull; @@ -34,6 +35,7 @@ public class WordCompletionTest extends NormalCompletionTestCase { return JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/completion/word/"; } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for txt, properties and xml") public void testKeyWordCompletion() { configureByFile("1.txt"); checkResultByFile("1_after.txt"); @@ -107,6 +109,7 @@ public class WordCompletionTest extends NormalCompletionTestCase { public void testTextInComment() { doTest(); } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for txt, properties and xml") public void testDollarsInPrefix() { configureByFile(getTestName(false) + ".txt"); checkResultByFile(getTestName(false) + "_after.txt"); diff --git a/java/java-tests/testSrc/com/intellij/java/spi/SPICompletionTest.java b/java/java-tests/testSrc/com/intellij/java/spi/SPICompletionTest.java index 907ede27038c..b570809528a0 100644 --- a/java/java-tests/testSrc/com/intellij/java/spi/SPICompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/java/spi/SPICompletionTest.java @@ -19,6 +19,7 @@ import com.intellij.codeInsight.lookup.LookupManager; import com.intellij.openapi.command.WriteCommandAction; import com.intellij.openapi.util.ThrowableComputable; import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.testFramework.NeedsIndicesState; import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase; import java.io.IOException; @@ -28,6 +29,7 @@ import java.io.IOException; */ public class SPICompletionTest extends LightJavaCodeInsightFixtureTestCase { + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for SPI") public void testQualifiedReference() { myFixture.addClass("package com.foo; public class Interface {}"); myFixture.addClass("package com.foo; public class Implementation extends Interface {}"); @@ -37,6 +39,7 @@ public class SPICompletionTest extends LightJavaCodeInsightFixtureTestCase { myFixture.checkResult("com.foo.Implementation"); } + @NeedsIndicesState.SmartMode(reason = "Smart completion in dumb mode is not supported for SPI") public void testCompletionAfterRenaming() throws IOException { VirtualFile file = myFixture.addFileToProject("META-INF/services/aaa", "").getVirtualFile(); myFixture.configureFromExistingVirtualFile(file); diff --git a/java/testFramework/src/com/intellij/testFramework/fixtures/JavaCodeInsightFixtureTestCase.java b/java/testFramework/src/com/intellij/testFramework/fixtures/JavaCodeInsightFixtureTestCase.java index b74dbd194cbe..12e174ead35f 100644 --- a/java/testFramework/src/com/intellij/testFramework/fixtures/JavaCodeInsightFixtureTestCase.java +++ b/java/testFramework/src/com/intellij/testFramework/fixtures/JavaCodeInsightFixtureTestCase.java @@ -10,6 +10,7 @@ import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiElementFactory; import com.intellij.psi.impl.PsiManagerEx; +import com.intellij.testFramework.TestIndexingModeSupporter; import com.intellij.testFramework.UsefulTestCase; import com.intellij.testFramework.builders.JavaModuleFixtureBuilder; import org.jetbrains.annotations.NonNls; @@ -20,8 +21,9 @@ import java.io.File; /** * @author peter */ -public abstract class JavaCodeInsightFixtureTestCase extends UsefulTestCase { +public abstract class JavaCodeInsightFixtureTestCase extends UsefulTestCase implements TestIndexingModeSupporter { protected JavaCodeInsightTestFixture myFixture; + private @NotNull IndexingMode myIndexingMode = IndexingMode.SMART; @NotNull @Override @@ -35,6 +37,7 @@ public abstract class JavaCodeInsightFixtureTestCase extends UsefulTestCase { TestFixtureBuilder projectBuilder = IdeaTestFixtureFactory.getFixtureFactory().createFixtureBuilder(getName()); myFixture = JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(projectBuilder.getFixture()); + myFixture = JavaIndexingModeCodeInsightTestFixture.Companion.wrapFixture(myFixture, myIndexingMode); JavaModuleFixtureBuilder moduleFixtureBuilder = projectBuilder.addModule(JavaModuleFixtureBuilder.class); if (toAddSourceRoot()) { moduleFixtureBuilder.addSourceContentRoot(myFixture.getTempDirPath()); @@ -106,4 +109,14 @@ public abstract class JavaCodeInsightFixtureTestCase extends UsefulTestCase { protected Module getModule() { return myFixture.getModule(); } + + @Override + public void setIndexingMode(@NotNull IndexingMode mode) { + myIndexingMode = mode; + } + + @Override + public @NotNull IndexingMode getIndexingMode() { + return myIndexingMode; + } } diff --git a/java/testFramework/src/com/intellij/testFramework/fixtures/JavaIndexingModeCodeInsightTestFixture.kt b/java/testFramework/src/com/intellij/testFramework/fixtures/JavaIndexingModeCodeInsightTestFixture.kt new file mode 100644 index 000000000000..acca0c726538 --- /dev/null +++ b/java/testFramework/src/com/intellij/testFramework/fixtures/JavaIndexingModeCodeInsightTestFixture.kt @@ -0,0 +1,122 @@ +// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.testFramework.fixtures + +import com.intellij.openapi.Disposable +import com.intellij.openapi.fileTypes.FileType +import com.intellij.openapi.vfs.VirtualFile +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiFile +import com.intellij.testFramework.TestIndexingModeSupporter + +open class JavaIndexingModeCodeInsightTestFixture private constructor(private val delegate: JavaCodeInsightTestFixture, + private val indexingMode: TestIndexingModeSupporter.IndexingMode) : + JavaCodeInsightTestFixture by delegate { + + companion object { + fun wrapFixture(delegate: JavaCodeInsightTestFixture, + indexingMode: TestIndexingModeSupporter.IndexingMode): JavaCodeInsightTestFixture { + return if (indexingMode === TestIndexingModeSupporter.IndexingMode.SMART) { + delegate + } + else JavaIndexingModeCodeInsightTestFixture(delegate, indexingMode) + } + } + + @Throws(Exception::class) + override fun setUp() { + delegate.setUp() + indexingMode.setUpTest(project, testRootDisposable) + } + + @Throws(Exception::class) + override fun tearDown() { + delegate.tearDown() + } + + private fun ensureIndexingStatus() { + indexingMode.ensureIndexingStatus(project) + } + + override fun copyFileToProject(sourceFilePath: String): VirtualFile { + val file = delegate.copyFileToProject(sourceFilePath) + ensureIndexingStatus() + return file + } + + override fun copyFileToProject(sourceFilePath: String, targetPath: String): VirtualFile { + val file = delegate.copyFileToProject(sourceFilePath, targetPath) + ensureIndexingStatus() + return file + } + + override fun copyDirectoryToProject(sourceFilePath: String, targetPath: String): VirtualFile { + val file = delegate.copyDirectoryToProject(sourceFilePath, targetPath) + ensureIndexingStatus() + return file + } + + override fun configureByFile(filePath: String): PsiFile? { + val file = delegate.configureByFile(filePath) + ensureIndexingStatus() + return file + } + + override fun configureByFiles(vararg filePaths: String): Array { + val files = delegate.configureByFiles(*filePaths) + ensureIndexingStatus() + return files + } + + override fun configureByText(fileType: FileType, text: String): PsiFile? { + val file = delegate.configureByText(fileType, text) + ensureIndexingStatus() + return file + } + + override fun configureByText(fileName: String, text: String): PsiFile? { + val file = delegate.configureByText(fileName, text) + ensureIndexingStatus() + return file + } + + override fun configureFromTempProjectFile(filePath: String): PsiFile? { + val file = delegate.configureFromTempProjectFile(filePath) + ensureIndexingStatus() + return file + } + + override fun configureFromExistingVirtualFile(virtualFile: VirtualFile) { + delegate.configureFromExistingVirtualFile(virtualFile) + ensureIndexingStatus() + } + + override fun addFileToProject(relativePath: String, fileText: String): PsiFile? { + val file = delegate.addFileToProject(relativePath, fileText) + ensureIndexingStatus() + return file + } + + override fun openFileInEditor(file: VirtualFile) { + delegate.openFileInEditor(file) + ensureIndexingStatus() + } + + override fun saveText(file: VirtualFile, text: String) { + delegate.saveText(file, text) + ensureIndexingStatus() + } + + override fun addClass(classText: String): PsiClass? { + val aClass = delegate.addClass(classText) + ensureIndexingStatus() + return aClass + } + + override fun getProjectDisposable(): Disposable { + return delegate.projectDisposable //default method of interface is not delegated by default + } + + override fun getTestRootDisposable(): Disposable { + return delegate.testRootDisposable //default method of interface is not delegated by default + } +} \ No newline at end of file diff --git a/java/testFramework/src/com/intellij/testFramework/fixtures/LightJavaCodeInsightFixtureTestCase.java b/java/testFramework/src/com/intellij/testFramework/fixtures/LightJavaCodeInsightFixtureTestCase.java index 8b9a2bf556ab..48b139d5e80e 100644 --- a/java/testFramework/src/com/intellij/testFramework/fixtures/LightJavaCodeInsightFixtureTestCase.java +++ b/java/testFramework/src/com/intellij/testFramework/fixtures/LightJavaCodeInsightFixtureTestCase.java @@ -23,7 +23,7 @@ import java.io.File; /** * @author peter */ -public abstract class LightJavaCodeInsightFixtureTestCase extends UsefulTestCase { +public abstract class LightJavaCodeInsightFixtureTestCase extends UsefulTestCase implements TestIndexingModeSupporter { protected static class ProjectDescriptor extends DefaultLightProjectDescriptor { protected final LanguageLevel myLanguageLevel; private final boolean myWithAnnotations; @@ -85,6 +85,8 @@ public abstract class LightJavaCodeInsightFixtureTestCase extends UsefulTestCase protected JavaCodeInsightTestFixture myFixture; + private @NotNull IndexingMode myIndexingMode = IndexingMode.SMART; + @Override protected void setUp() throws Exception { super.setUp(); @@ -93,6 +95,7 @@ public abstract class LightJavaCodeInsightFixtureTestCase extends UsefulTestCase TestFixtureBuilder fixtureBuilder = factory.createLightFixtureBuilder(getProjectDescriptor()); IdeaProjectTestFixture fixture = fixtureBuilder.getFixture(); myFixture = JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(fixture, getTempDirFixture()); + myFixture = JavaIndexingModeCodeInsightTestFixture.Companion.wrapFixture(myFixture, myIndexingMode); myFixture.setTestDataPath(getTestDataPath()); myFixture.setUp(); @@ -172,4 +175,14 @@ public abstract class LightJavaCodeInsightFixtureTestCase extends UsefulTestCase public PsiFile createLightFile(String fileName, Language language, String text) { return PsiFileFactory.getInstance(getProject()).createFileFromText(fileName, language, text, false, true); } + + @Override + public void setIndexingMode(@NotNull IndexingMode mode) { + myIndexingMode = mode; + } + + @Override + public @NotNull IndexingMode getIndexingMode() { + return myIndexingMode; + } } \ No newline at end of file diff --git a/platform/core-api/src/com/intellij/openapi/project/DumbUtil.java b/platform/core-api/src/com/intellij/openapi/project/DumbUtil.java index a3452a52f58f..a02637d8b6c6 100644 --- a/platform/core-api/src/com/intellij/openapi/project/DumbUtil.java +++ b/platform/core-api/src/com/intellij/openapi/project/DumbUtil.java @@ -26,4 +26,10 @@ public interface DumbUtil { @ApiStatus.Internal @ApiStatus.Experimental @NotNull List filterByDumbAwarenessHonoringIgnoring(@NotNull Collection collection); + + /** + * @return true iff one may use file based indices, i.e. project is not in dumb mode, or + * {@link com.intellij.util.indexing.FileBasedIndex#ignoreDumbMode(Runnable, com.intellij.util.indexing.DumbModeAccessType)} was used + */ + boolean mayUseIndices(); } diff --git a/platform/core-api/src/com/intellij/psi/util/PsiModificationTracker.java b/platform/core-api/src/com/intellij/psi/util/PsiModificationTracker.java index 1b181c081543..8fbb1a104fb4 100644 --- a/platform/core-api/src/com/intellij/psi/util/PsiModificationTracker.java +++ b/platform/core-api/src/com/intellij/psi/util/PsiModificationTracker.java @@ -16,9 +16,8 @@ import org.jetbrains.annotations.NotNull; * to check if PSI has changed since they accessed it last time. This can be used to flush and rebuild various internal caches. * See {@link #getModificationCount()} * - *
  • Make a {@link CachedValue} instance dependent on a specific PSI modification tracker. - * To achieve that, one should can one of the constants in this interface as {@link CachedValueProvider.Result} - * dependencies. + *
  • Make a {@link CachedValue} instance outdated on every physical PSI change. + * To achieve that, one should use {@link #MODIFICATION_COUNT} as {@link CachedValueProvider.Result} dependency. * *
  • Subscribe to any PSI change (for example, to drop caches in the listener manually). * See {@link PsiModificationTracker.Listener} diff --git a/platform/indexing-impl/src/com/intellij/psi/impl/search/PsiSearchHelperImpl.java b/platform/indexing-impl/src/com/intellij/psi/impl/search/PsiSearchHelperImpl.java index 3dfeccb5f937..2cd28016fdc9 100644 --- a/platform/indexing-impl/src/com/intellij/psi/impl/search/PsiSearchHelperImpl.java +++ b/platform/indexing-impl/src/com/intellij/psi/impl/search/PsiSearchHelperImpl.java @@ -19,6 +19,7 @@ import com.intellij.openapi.progress.impl.CoreProgressManager; import com.intellij.openapi.progress.util.ProgressWrapper; import com.intellij.openapi.progress.util.TooManyUsagesStatus; import com.intellij.openapi.project.DumbService; +import com.intellij.openapi.project.DumbUtil; import com.intellij.openapi.project.IndexNotReadyException; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.*; @@ -516,7 +517,7 @@ public class PsiSearchHelperImpl implements PsiSearchHelper { ApplicationUtil.tryRunReadAction(() -> { Project project = myManager.getProject(); if (project.isDisposed()) throw new ProcessCanceledException(); - if (DumbService.isDumb(project) && FileBasedIndex.getInstance().getCurrentDumbModeAccessType() == null) { + if (!DumbUtil.getInstance(project).mayUseIndices()) { throw ApplicationUtil.CannotRunReadActionException.create(); } diff --git a/platform/lang-impl/src/com/intellij/openapi/roots/impl/PushedFilePropertiesUpdaterImpl.java b/platform/lang-impl/src/com/intellij/openapi/roots/impl/PushedFilePropertiesUpdaterImpl.java index d592f8b8c038..5b8de89b05b3 100644 --- a/platform/lang-impl/src/com/intellij/openapi/roots/impl/PushedFilePropertiesUpdaterImpl.java +++ b/platform/lang-impl/src/com/intellij/openapi/roots/impl/PushedFilePropertiesUpdaterImpl.java @@ -386,7 +386,10 @@ public final class PushedFilePropertiesUpdaterImpl extends PushedFilePropertiesU @Override public void filePropertiesChanged(@NotNull final VirtualFile file) { ApplicationManager.getApplication().assertReadAccessAllowed(); - ((FileBasedIndexImpl)FileBasedIndex.getInstance()).requestReindex(file, false); + FileBasedIndex fileBasedIndex = FileBasedIndex.getInstance(); + if (fileBasedIndex instanceof FileBasedIndexImpl) { + ((FileBasedIndexImpl) fileBasedIndex).requestReindex(file, false); + } for (final Project project : ProjectManager.getInstance().getOpenProjects()) { reloadPsi(file, project); } diff --git a/platform/lang-impl/src/com/intellij/psi/stubs/StubIndexImpl.java b/platform/lang-impl/src/com/intellij/psi/stubs/StubIndexImpl.java index 5886bae3ded6..ad14ceff36b9 100644 --- a/platform/lang-impl/src/com/intellij/psi/stubs/StubIndexImpl.java +++ b/platform/lang-impl/src/com/intellij/psi/stubs/StubIndexImpl.java @@ -301,7 +301,7 @@ public final class StubIndexImpl extends StubIndexEx implements PersistentStateC IdIterator ids = getContainingIds(indexKey, key, project, idFilter, scope); PersistentFS fs = PersistentFS.getInstance(); - IntPredicate accessibleFileFilter = ((FileBasedIndexImpl)FileBasedIndex.getInstance()).getAccessibleFileIdFilter(project); + IntPredicate accessibleFileFilter = ((FileBasedIndexEx)FileBasedIndex.getInstance()).getAccessibleFileIdFilter(project); // already ensured up-to-date in getContainingIds() method try { while (ids.hasNext()) { @@ -450,13 +450,13 @@ public final class StubIndexImpl extends StubIndexEx implements PersistentStateC final @NotNull Project project, @Nullable IdFilter idFilter, final @Nullable GlobalSearchScope scope) { - final FileBasedIndexImpl fileBasedIndex = (FileBasedIndexImpl)FileBasedIndex.getInstance(); + final FileBasedIndexEx fileBasedIndex = (FileBasedIndexEx)FileBasedIndex.getInstance(); ID stubUpdatingIndexId = StubUpdatingIndex.INDEX_ID; final UpdatableIndex index = getIndex(indexKey); // wait for initialization to finish if (index == null || !fileBasedIndex.ensureUpToDate(stubUpdatingIndexId, project, scope, null)) return IdIterator.EMPTY; if (idFilter == null) { - idFilter = ((FileBasedIndexImpl)FileBasedIndex.getInstance()).projectIndexableFiles(project); + idFilter = ((FileBasedIndexEx)FileBasedIndex.getInstance()).projectIndexableFiles(project); } UpdatableIndex stubUpdatingIndex = fileBasedIndex.getIndex(stubUpdatingIndexId); @@ -717,7 +717,7 @@ public final class StubIndexImpl extends StubIndexEx implements PersistentStateC } static UpdatableIndex getStubUpdatingIndex() { - return ((FileBasedIndexImpl)FileBasedIndex.getInstance()).getIndex(StubUpdatingIndex.INDEX_ID); + return ((FileBasedIndexEx)FileBasedIndex.getInstance()).getIndex(StubUpdatingIndex.INDEX_ID); } private static final class CompositeKey { diff --git a/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexEx.java b/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexEx.java index fd7e625ca36d..c46acc3efb31 100644 --- a/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexEx.java +++ b/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexEx.java @@ -51,7 +51,7 @@ public abstract class FileBasedIndexEx extends FileBasedIndex { public abstract ProjectIndexableFilesFilter projectIndexableFiles(@Nullable Project project); @ApiStatus.Internal - abstract UpdatableIndex getIndex(ID indexId); + public abstract UpdatableIndex getIndex(ID indexId); @ApiStatus.Internal public abstract void waitUntilIndicesAreInitialized(); diff --git a/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java b/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java index d6f0044ad373..ce6aa2761c3f 100644 --- a/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java +++ b/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java @@ -276,7 +276,10 @@ public final class FileBasedIndexImpl extends FileBasedIndexEx { static class MyShutDownTask implements Runnable { @Override public void run() { - ((FileBasedIndexImpl)FileBasedIndex.getInstance()).performShutdown(false); + FileBasedIndex fileBasedIndex = FileBasedIndex.getInstance(); + if (fileBasedIndex instanceof FileBasedIndexImpl) { + ((FileBasedIndexImpl)fileBasedIndex).performShutdown(false); + } } } diff --git a/platform/platform-impl/src/com/intellij/openapi/project/DumbUtilImpl.java b/platform/platform-impl/src/com/intellij/openapi/project/DumbUtilImpl.java index b1ae054e141f..00e811dd332d 100644 --- a/platform/platform-impl/src/com/intellij/openapi/project/DumbUtilImpl.java +++ b/platform/platform-impl/src/com/intellij/openapi/project/DumbUtilImpl.java @@ -19,15 +19,19 @@ public class DumbUtilImpl implements DumbUtil { @Override @Contract(pure = true) public @NotNull List filterByDumbAwarenessHonoringIgnoring(@NotNull Collection collection) { - DumbService service = DumbService.getInstance(myProject); - if (!service.isDumb() || FileBasedIndex.getInstance().getCurrentDumbModeAccessType() == null) { - return service.filterByDumbAwareness(collection); + if (!mayUseIndices()) { + return DumbService.getInstance(myProject).filterByDumbAwareness(collection); } if (collection instanceof List) { - return (List)collection; + return (List) collection; } return new ArrayList<>(collection); } + + @Override + public boolean mayUseIndices() { + return !DumbService.getInstance(myProject).isDumb() || FileBasedIndex.getInstance().getCurrentDumbModeAccessType() != null; + } } diff --git a/platform/testFramework/src/com/intellij/testFramework/EmptyFileBasedIndex.java b/platform/testFramework/src/com/intellij/testFramework/EmptyFileBasedIndex.java new file mode 100644 index 000000000000..b979d3f0087a --- /dev/null +++ b/platform/testFramework/src/com/intellij/testFramework/EmptyFileBasedIndex.java @@ -0,0 +1,362 @@ +// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.testFramework; + +import com.intellij.openapi.progress.ProgressIndicator; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.roots.ContentIterator; +import com.intellij.openapi.util.Computable; +import com.intellij.openapi.util.Condition; +import com.intellij.openapi.util.ThrowableComputable; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.util.Processor; +import com.intellij.util.indexing.*; +import com.intellij.util.indexing.impl.AbstractUpdateData; +import com.intellij.util.indexing.roots.IndexableFilesProvider; +import com.intellij.util.indexing.snapshot.SnapshotSingleValueIndexStorage; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.function.IntPredicate; + +public class EmptyFileBasedIndex extends FileBasedIndexEx { + private static final ThreadLocal ourDumbModeAccessType = new ThreadLocal<>(); + + @Override + public void iterateIndexableFiles(@NotNull ContentIterator processor, @NotNull Project project, @Nullable ProgressIndicator indicator) { + } + + @Override + public @Nullable VirtualFile getFileBeingCurrentlyIndexed() { + return null; + } + + @Override + public DumbModeAccessType getCurrentDumbModeAccessType() { + return ourDumbModeAccessType.get(); + } + + @Override + public void registerIndexableSet(@NotNull IndexableFileSet set, @Nullable Project project) { + + } + + @Override + public void removeIndexableSet(@NotNull IndexableFileSet set) { + + } + + @Override + public VirtualFile findFileById(Project project, int id) { + return null; + } + + @Override + public void requestRebuild(@NotNull ID indexId) { + super.requestRebuild(indexId); + } + + @Override + public @NotNull List getValues(@NotNull ID indexId, @NotNull K dataKey, @NotNull GlobalSearchScope filter) { + return Collections.emptyList(); + } + + @Override + public @NotNull Collection getContainingFiles(@NotNull ID indexId, + @NotNull K dataKey, + @NotNull GlobalSearchScope filter) { + return Collections.emptyList(); + } + + @Override + public boolean processValues(@NotNull ID indexId, + @NotNull K dataKey, + @Nullable VirtualFile inFile, + @NotNull ValueProcessor processor, + @NotNull GlobalSearchScope filter) { + return true; + } + + @Override + public boolean processValues(@NotNull ID indexId, + @NotNull K dataKey, + @Nullable VirtualFile inFile, + @NotNull ValueProcessor processor, + @NotNull GlobalSearchScope filter, + @Nullable IdFilter idFilter) { + return super.processValues(indexId, dataKey, inFile, processor, filter, idFilter); + } + + @Override + public long getIndexModificationStamp(@NotNull ID indexId, @NotNull Project project) { + return 0; + } + + @Override + public boolean processFilesContainingAllKeys(@NotNull ID indexId, + @NotNull Collection dataKeys, + @NotNull GlobalSearchScope filter, + @Nullable Condition valueChecker, + @NotNull Processor processor) { + return true; + } + + @Override + public @NotNull Collection getAllKeys(@NotNull ID indexId, @NotNull Project project) { + return Collections.emptyList(); + } + + @Override + public void ensureUpToDate(@NotNull ID indexId, @Nullable Project project, @Nullable GlobalSearchScope filter) { + + } + + @Override + public void requestRebuild(@NotNull ID indexId, @NotNull Throwable throwable) { + + } + + @Override + public void scheduleRebuild(@NotNull ID indexId, @NotNull Throwable e) { + + } + + @Override + public void requestReindex(@NotNull VirtualFile file) { + + } + + @Override + public boolean getFilesWithKey(@NotNull ID indexId, + @NotNull Set dataKeys, + @NotNull Processor processor, + @NotNull GlobalSearchScope filter) { + return true; + } + + @Override + public void ignoreDumbMode(@NotNull Runnable command, @NotNull DumbModeAccessType dumbModeAccessType) { + ignoreDumbMode(dumbModeAccessType, () -> { + command.run(); + return null; + }); + } + + @Override + public T ignoreDumbMode(@NotNull DumbModeAccessType dumbModeAccessType, + @NotNull ThrowableComputable computable) throws E { + boolean setAccessType = true; + DumbModeAccessType currentAccessType = ourDumbModeAccessType.get(); + if (currentAccessType != null) { + if (currentAccessType == dumbModeAccessType) { + setAccessType = false; + } + else { + throw new AssertionError( + "Reentrant dumb mode ignorance. Current mode: " + currentAccessType + ", Requested mode: " + dumbModeAccessType); + } + } + if (setAccessType) ourDumbModeAccessType.set(dumbModeAccessType); + try { + return computable.compute(); + } + finally { + if (setAccessType) ourDumbModeAccessType.set(null); + } + } + + @Override + public boolean processAllKeys(@NotNull ID indexId, @NotNull Processor processor, @Nullable Project project) { + return true; + } + + @Override + public boolean processAllKeys(@NotNull ID indexId, + @NotNull Processor processor, + @NotNull GlobalSearchScope scope, + @Nullable IdFilter idFilter) { + return super.processAllKeys(indexId, processor, scope, idFilter); + } + + @Override + public @NotNull Map getFileData(@NotNull ID id, @NotNull VirtualFile virtualFile, @NotNull Project project) { + return Collections.emptyMap(); + } + + @Override + public void invalidateCaches() { + } + + @Override + public @NotNull IntPredicate getAccessibleFileIdFilter(@Nullable Project project) { + return value -> false; + } + + @Override + public ProjectIndexableFilesFilter projectIndexableFiles(@Nullable Project project) { + return null; + } + + @Override + public void waitUntilIndicesAreInitialized() { + } + + @Override + public boolean ensureUpToDate(@NotNull ID indexId, + @Nullable Project project, + @Nullable GlobalSearchScope filter, + @Nullable VirtualFile restrictedFile) { + return true; + } + + @Override + public @NotNull List getOrderedIndexableFilesProviders(@NotNull Project project) { + return super.getOrderedIndexableFilesProviders(project); + } + + @Override + public UpdatableIndex getIndex(ID indexId) { + return EmptyIndex.getInstance(); + } + + private static class EmptyIndex implements UpdatableIndex { + @SuppressWarnings("rawtypes") + private static final EmptyIndex INSTANCE = new EmptyIndex(); + private final ReentrantReadWriteLock myLock = new ReentrantReadWriteLock(); + + + @SuppressWarnings("unchecked") + static EmptyIndex getInstance() { + return INSTANCE; + } + + @Override + public boolean processAllKeys(@NotNull Processor processor, + @NotNull GlobalSearchScope scope, + @Nullable IdFilter idFilter) { + return true; + } + + @Override + public @NotNull ReadWriteLock getLock() { + return myLock; + } + + @Override + public @NotNull Map getIndexedFileData(int fileId) { + return Collections.emptyMap(); + } + + @Override + public void setIndexedStateForFile(int fileId, @NotNull IndexedFile file) { + throw new UnsupportedOperationException(); + } + + @Override + public void resetIndexedStateForFile(int fileId) { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull FileIndexingState getIndexingStateForFile(int fileId, @NotNull IndexedFile file) { + throw new UnsupportedOperationException(); + } + + @Override + public long getModificationStamp() { + return 0; + } + + @Override + public void removeTransientDataForFile(int inputId) { + } + + @Override + public void removeTransientDataForKeys(int inputId, @NotNull Collection keys) { + } + + @Override + public @NotNull IndexExtension getExtension() { + throw new UnsupportedOperationException(); + } + + @Override + public void updateWithMap(@NotNull AbstractUpdateData updateData) { + throw new UnsupportedOperationException(); + } + + @Override + public void setBufferingEnabled(boolean enabled) { + } + + @Override + public void cleanupMemoryStorage() { + } + + @Override + public void cleanupForNextTest() { + } + + @Override + public void dumpStatistics() { + + } + + @Override + public @NotNull ValueContainer getData(@NotNull Key key) { + return SnapshotSingleValueIndexStorage.empty(); + } + + @Override + public @NotNull Computable mapInputAndPrepareUpdate(int inputId, @Nullable FileContent content) { + throw new UnsupportedOperationException(); + } + + @Override + public void flush() { + } + + @Override + public void clear() { + } + + @Override + public void dispose() { + } + + private static final Lock NO_LOCK = new Lock() { + @Override + public void lock() { + } + + @Override + public void lockInterruptibly() { + } + + @Override + public boolean tryLock() { + return false; + } + + @Override + public boolean tryLock(long time, @NotNull TimeUnit unit) { + return false; + } + + @Override + public void unlock() { + } + + @NotNull + @Override + public java.util.concurrent.locks.Condition newCondition() { + throw new UnsupportedOperationException(); + } + }; + } +} diff --git a/platform/testFramework/src/com/intellij/testFramework/LightPlatformCodeInsightTestCase.java b/platform/testFramework/src/com/intellij/testFramework/LightPlatformCodeInsightTestCase.java index 4db1ead1e09d..048e471e4eb1 100644 --- a/platform/testFramework/src/com/intellij/testFramework/LightPlatformCodeInsightTestCase.java +++ b/platform/testFramework/src/com/intellij/testFramework/LightPlatformCodeInsightTestCase.java @@ -54,10 +54,11 @@ import java.io.IOException; import java.nio.charset.StandardCharsets; import java.util.*; -public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTestCase { +public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTestCase implements TestIndexingModeSupporter { private Editor myEditor; private PsiFile myFile; private VirtualFile myVFile; + private TestIndexingModeSupporter.IndexingMode myIndexingMode = IndexingMode.SMART; @Override protected void runTest() throws Throwable { @@ -176,6 +177,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest } EditorTestUtil.setCaretsAndSelection(getEditor(), caretsState); setupEditorForInjectedLanguage(); + myIndexingMode.ensureIndexingStatus(getProject()); return document; }); } @@ -192,6 +194,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest ((EditorImpl)editor).setCaretActive(); EditorTestUtil.setCaretsAndSelection(editor, caretsState); + myIndexingMode.ensureIndexingStatus(getProject()); return editor; }); } @@ -203,6 +206,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest DaemonCodeAnalyzer.getInstance(getProject()).restart(); assertNotNull(editor); ((EditorImpl)editor).setCaretActive(); + myIndexingMode.ensureIndexingStatus(getProject()); return editor; } @@ -215,7 +219,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest myEditor = createSaveAndOpenFile(relativePath, fileText); myVFile = FileDocumentManager.getInstance().getFile(getEditor().getDocument()); myFile = getPsiManager().findFile(myVFile); - + myIndexingMode.ensureIndexingStatus(getProject()); return getEditor().getDocument(); } @@ -223,6 +227,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest protected Editor createSaveAndOpenFile(@NotNull String relativePath, @NotNull String fileText) { Editor editor = createEditor(VfsTestUtil.createFile(getSourceRoot(), relativePath, fileText)); PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); + myIndexingMode.ensureIndexingStatus(getProject()); return editor; } @@ -259,9 +264,16 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest FileEditorManager.getInstance(getProject()).closeFile(myVFile); myVFile.delete(getProject()); }); + myIndexingMode.ensureIndexingStatus(getProject()); } } + @Override + protected void setUp() throws Exception { + super.setUp(); + myIndexingMode.setUpTest(getProject(), getTestRootDisposable()); + } + @Override protected void tearDown() throws Exception { try { @@ -657,7 +669,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest * @see FileBasedTestCaseHelperEx * @Parameterized.Parameter fields are injected on parameterized test creation. */ - @Parameterized.Parameter() + @Parameterized.Parameter public String myFileSuffix; /** @@ -748,6 +760,7 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest invokeTestRunnable(() -> { try { setUp(); + myIndexingMode.ensureIndexingStatus(getProject()); } catch (Throwable e) { throwables[0] = e; @@ -804,4 +817,14 @@ public abstract class LightPlatformCodeInsightTestCase extends LightPlatformTest protected void setVFile(VirtualFile virtualFile) { myVFile = virtualFile; } + + @Override + public void setIndexingMode(@NotNull IndexingMode mode) { + myIndexingMode = mode; + } + + @Override + public @NotNull IndexingMode getIndexingMode() { + return myIndexingMode; + } } diff --git a/platform/testFramework/src/com/intellij/testFramework/NeedsIndicesState.java b/platform/testFramework/src/com/intellij/testFramework/NeedsIndicesState.java new file mode 100644 index 000000000000..197638365bb9 --- /dev/null +++ b/platform/testFramework/src/com/intellij/testFramework/NeedsIndicesState.java @@ -0,0 +1,49 @@ +// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.testFramework; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +public interface NeedsIndicesState { + + /** + * Used to mark those completion tests that are not expected to work in dumb mode even with full indices. + * Please also provide reason the test fails when you use this annotation. + * + * @see com.intellij.java.codeInsight.completion.JavaCompletionTestSuite + * @see com.jetbrains.php.slowTests.PhpDumbCompletionTestSuite + */ + @Retention(RetentionPolicy.RUNTIME) + @Target(ElementType.METHOD) + @interface SmartMode { + String reason(); + } + + /** + * Used to mark those completion tests that are not expected to work in dumb mode + * with runtime-only indices (of JDK, php standard libraries, etc.), but work with full indices + * + * @see com.intellij.java.codeInsight.completion.JavaCompletionTestSuite + * @see com.jetbrains.php.slowTests.PhpDumbCompletionTestSuite + */ + @Retention(RetentionPolicy.RUNTIME) + @Target({ElementType.METHOD, ElementType.TYPE}) + @interface FullIndices { + String reason() default ""; + } + + /** + * Used to mark those completion tests that are not expected to work in dumb mode with empty indices, + * but works with indices of standard library only (of JDK, php standard libraries, etc.) + * + * @see com.intellij.java.codeInsight.completion.JavaCompletionTestSuite + * @see com.jetbrains.php.slowTests.PhpDumbCompletionTestSuite + */ + @Retention(RetentionPolicy.RUNTIME) + @Target({ElementType.METHOD, ElementType.TYPE}) + @interface StandardLibraryIndices { + String reason() default ""; + } +} diff --git a/platform/testFramework/src/com/intellij/testFramework/TestIndexingModeSupporter.java b/platform/testFramework/src/com/intellij/testFramework/TestIndexingModeSupporter.java new file mode 100644 index 000000000000..df48c829b70c --- /dev/null +++ b/platform/testFramework/src/com/intellij/testFramework/TestIndexingModeSupporter.java @@ -0,0 +1,157 @@ +// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package com.intellij.testFramework; + +import com.intellij.openapi.Disposable; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.project.DumbServiceImpl; +import com.intellij.openapi.project.Project; +import com.intellij.util.indexing.FileBasedIndex; +import com.intellij.util.indexing.UnindexedFilesUpdater; +import junit.framework.TestCase; +import junit.framework.TestSuite; +import org.jetbrains.annotations.NotNull; +import org.junit.internal.MethodSorter; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; + +import static junit.framework.TestSuite.warning; + +public interface TestIndexingModeSupporter { + enum IndexingMode { + SMART { + @Override + public void setUpTest(@NotNull Project project, @NotNull Disposable testRootDisposable) {} + }, DUMB_FULL_INDEX { + @Override + public void setUpTest(@NotNull Project project, @NotNull Disposable testRootDisposable) { + indexEverythingAndBecomeDumb(project); + } + + @Override + public void ensureIndexingStatus(@NotNull Project project) { + DumbServiceImpl dumbService = DumbServiceImpl.getInstance(project); + ApplicationManager.getApplication().invokeAndWait(() -> { + dumbService.setDumb(false); + dumbService.queueTask(new UnindexedFilesUpdater(project)); + dumbService.setDumb(true); + }); + } + }, DUMB_RUNTIME_ONLY_INDEX { + @Override + public void setUpTest(@NotNull Project project, @NotNull Disposable testRootDisposable) { + becomeDumb(project); + } + }, DUMB_EMPTY_INDEX { + @Override + public void setUpTest(@NotNull Project project, @NotNull Disposable testRootDisposable) { + ServiceContainerUtil + .replaceService(ApplicationManager.getApplication(), FileBasedIndex.class, new EmptyFileBasedIndex(), testRootDisposable); + becomeDumb(project); + } + }; + + public abstract void setUpTest(@NotNull Project project, + @NotNull Disposable testRootDisposable); + + public void ensureIndexingStatus(@NotNull Project project) { + } + + private static void becomeDumb(@NotNull Project project) { + ApplicationManager.getApplication().invokeAndWait(() -> { + DumbServiceImpl.getInstance(project).setDumb(true); + }); + } + + private static void indexEverythingAndBecomeDumb(@NotNull Project project) { + DumbServiceImpl dumbService = DumbServiceImpl.getInstance(project); + ApplicationManager.getApplication().invokeAndWait(() -> { + dumbService.setDumb(false); + dumbService.queueTask(new UnindexedFilesUpdater(project)); + dumbService.setDumb(true); + }); + } + } + + void setIndexingMode(@NotNull IndexingMode mode); + + @NotNull IndexingMode getIndexingMode(); + + static void addTest(@NotNull Class aClass, + @NotNull TestIndexingModeSupporter.IndexingModeTestHandler handler, + @NotNull TestSuite parentSuite) { + if (handler.shouldIgnore(aClass)) return; + try { + TestSuite suite = handler.createTestSuite(); + suite.setName(aClass.getSimpleName()); + boolean foundTests = false; + Constructor constructor = aClass.getConstructor(); + for (Method declaredMethod : MethodSorter.getDeclaredMethods(aClass)) { + if (!Modifier.isPublic(declaredMethod.getModifiers())) continue; + String methodName = declaredMethod.getName(); + if (!methodName.startsWith("test")) continue; + if (TestFrameworkUtil.isPerformanceTest(methodName, aClass.getName())) continue; + if (handler.shouldIgnore(declaredMethod, aClass)) continue; + TestIndexingModeSupporter aCase = constructor.newInstance(); + aCase.setIndexingMode(handler.getIndexingMode()); + if (aCase instanceof TestCase) { + TestCase testCase = (TestCase)aCase; + testCase.setName(methodName); + suite.addTest(testCase); + } + else { + parentSuite.addTest(warning(aClass.getName() + "is not a TestSuite")); + } + foundTests = true; + } + if (foundTests) { + parentSuite.addTest(suite); + } + } + catch (NoSuchMethodException e) { + parentSuite.addTest(warning("Failed to find default constructor for " + aClass.getName() + ", see log")); + e.printStackTrace(); + } + catch (IllegalAccessException | InstantiationException | InvocationTargetException e) { + parentSuite.addTest(warning("Failed to instantiate " + aClass.getName() + ", see log")); + e.printStackTrace(); + } + } + + abstract class IndexingModeTestHandler { + public final String myTestSuiteName; + public final String myTestNamePrefix; + + protected IndexingModeTestHandler(@NotNull String testSuiteName, @NotNull String testNamePrefix) { + myTestSuiteName = testSuiteName; + myTestNamePrefix = testNamePrefix; + } + + public TestSuite createTestSuite() { + return new NamedTestSuite(myTestSuiteName, myTestNamePrefix); + } + + public abstract boolean shouldIgnore(@NotNull Class aClass); + + public abstract boolean shouldIgnore(@NotNull Method method, + @NotNull Class aClass); + + public abstract @NotNull TestIndexingModeSupporter.IndexingMode getIndexingMode(); + + private static class NamedTestSuite extends TestSuite { + private final String myPrefix; + + private NamedTestSuite(String name, String prefix) { + super(name); + myPrefix = prefix; + } + + @Override + public void setName(String name) { + super.setName(myPrefix + name); + } + } + } +} diff --git a/platform/testFramework/src/com/intellij/testFramework/UsefulTestCase.java b/platform/testFramework/src/com/intellij/testFramework/UsefulTestCase.java index 497aa87c0ee2..4f48bd2e9237 100644 --- a/platform/testFramework/src/com/intellij/testFramework/UsefulTestCase.java +++ b/platform/testFramework/src/com/intellij/testFramework/UsefulTestCase.java @@ -1121,9 +1121,9 @@ public abstract class UsefulTestCase extends TestCase { EdtTestUtil.runInEdtAndWait(() -> { Application app = ApplicationManager.getApplication(); if (app != null && !app.isDisposed()) { - FileBasedIndexImpl index = (FileBasedIndexImpl)app.getServiceIfCreated(FileBasedIndex.class); - if (index != null) { - index.getChangedFilesCollector().waitForVfsEventsExecuted(timeout, timeUnit); + FileBasedIndex index = app.getServiceIfCreated(FileBasedIndex.class); + if (index instanceof FileBasedIndexImpl) { + ((FileBasedIndexImpl)index).getChangedFilesCollector().waitForVfsEventsExecuted(timeout, timeUnit); } DocumentCommitThread commitThread = (DocumentCommitThread)app.getServiceIfCreated(DocumentCommitProcessor.class);