mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-01-06 03:21:12 +07:00
1762 lines
52 KiB
Groovy
1762 lines
52 KiB
Groovy
/*
|
|
* Copyright 2000-2016 JetBrains s.r.o.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package com.intellij.codeInsight.completion
|
|
import com.intellij.JavaTestUtil
|
|
import com.intellij.codeInsight.CodeInsightSettings
|
|
import com.intellij.codeInsight.JavaProjectCodeInsightSettings
|
|
import com.intellij.codeInsight.lookup.Lookup
|
|
import com.intellij.codeInsight.lookup.LookupElement
|
|
import com.intellij.codeInsight.lookup.LookupElementPresentation
|
|
import com.intellij.codeInsight.lookup.LookupManager
|
|
import com.intellij.codeInsight.lookup.impl.LookupImpl
|
|
import com.intellij.lang.java.JavaLanguage
|
|
import com.intellij.openapi.actionSystem.IdeActions
|
|
import com.intellij.psi.PsiClass
|
|
import com.intellij.psi.PsiDocumentManager
|
|
import com.intellij.psi.PsiMethod
|
|
import com.intellij.psi.codeStyle.CodeStyleSettingsManager
|
|
import com.intellij.psi.codeStyle.CommonCodeStyleSettings
|
|
import com.intellij.psi.impl.PsiDocumentManagerBase
|
|
import com.intellij.util.ui.UIUtil
|
|
import com.siyeh.ig.style.UnqualifiedFieldAccessInspection
|
|
|
|
class NormalCompletionTest extends LightFixtureCompletionTestCase {
|
|
@Override
|
|
protected String getBasePath() {
|
|
return JavaTestUtil.getRelativeJavaTestDataPath() + "/codeInsight/completion/normal/"
|
|
}
|
|
|
|
void testSimple() throws Exception {
|
|
configureByFile("Simple.java")
|
|
assertStringItems("_local1", "_local2", "_field", "_method", "_baseField", "_baseMethod")
|
|
}
|
|
|
|
void testCastToPrimitive1() throws Exception {
|
|
configureByFile("CastToPrimitive1.java")
|
|
|
|
for (final LookupElement item : myItems) {
|
|
if (item.getLookupString().equals("int")) return
|
|
}
|
|
assertTrue(false)
|
|
}
|
|
|
|
void testCastToPrimitive2() throws Exception {
|
|
configureByFile("CastToPrimitive2.java")
|
|
|
|
for (final LookupElement item : myItems) {
|
|
if (item.getLookupString().equals("int")) return
|
|
}
|
|
assertTrue(false)
|
|
}
|
|
|
|
void testCastToPrimitive3() throws Exception {
|
|
configureByFile("CastToPrimitive3.java")
|
|
|
|
for (final LookupElement item : myItems) {
|
|
if (item.getLookupString().equals("int")) return
|
|
}
|
|
assertTrue(false)
|
|
}
|
|
|
|
void testWriteInInvokeLater() throws Exception {
|
|
configureByFile("WriteInInvokeLater.java")
|
|
}
|
|
|
|
void testQualifiedNew1() throws Exception {
|
|
configure()
|
|
assertStringItems "IInner", "Inner"
|
|
}
|
|
|
|
void testQualifiedNew2() throws Exception {
|
|
configure()
|
|
assertStringItems "AnInner", "Inner"
|
|
}
|
|
|
|
void testKeywordsInName() throws Exception {
|
|
doTest 'a\n'
|
|
}
|
|
|
|
void testSimpleVariable() throws Exception { doTest('\n') }
|
|
|
|
void testTypeParameterItemPresentation() {
|
|
configure()
|
|
LookupElementPresentation presentation = renderElement(myItems[0])
|
|
assert "Param" == presentation.itemText
|
|
assert presentation.tailText == " (type parameter of Foo)"
|
|
assert !presentation.typeText
|
|
assert !presentation.icon
|
|
assert !presentation.itemTextBold
|
|
|
|
presentation = renderElement(myItems[1])
|
|
assert "Param2" == presentation.itemText
|
|
assert presentation.tailText == " (type parameter of goo)"
|
|
}
|
|
|
|
void testDisplayDefaultValueInAnnotationMethods() {
|
|
configure()
|
|
LookupElementPresentation presentation = renderElement(myItems[0])
|
|
assert "myBool" == presentation.itemText
|
|
assert presentation.tailText == " default false"
|
|
assert presentation.tailFragments[0].grayed
|
|
assert !presentation.typeText
|
|
assert !presentation.itemTextBold
|
|
|
|
presentation = renderElement(myItems[1])
|
|
assert "myString" == presentation.itemText
|
|
assert presentation.tailText == ' default "unknown"'
|
|
}
|
|
|
|
void testMethodItemPresentation() {
|
|
configure()
|
|
LookupElementPresentation presentation = renderElement(myItems[0])
|
|
assert "equals" == presentation.itemText
|
|
assert "(Object anObject)" == presentation.tailText
|
|
assert "boolean" == presentation.typeText
|
|
|
|
assert !presentation.tailGrayed
|
|
assert presentation.itemTextBold
|
|
}
|
|
|
|
private LookupElementPresentation renderElement(LookupElement element) {
|
|
return LookupElementPresentation.renderElement(element)
|
|
}
|
|
|
|
void testFieldItemPresentationGenerics() {
|
|
configure()
|
|
LookupElementPresentation presentation = renderElement(myItems[0])
|
|
assert "target" == presentation.itemText
|
|
assert !presentation.tailText
|
|
assert "String" == presentation.typeText
|
|
}
|
|
|
|
void testMethodItemPresentationGenerics() {
|
|
configure()
|
|
LookupElementPresentation presentation = renderElement(myItems[1])
|
|
assert "add" == presentation.itemText
|
|
assert "(int index, String element)" == presentation.tailText
|
|
assert "void" == presentation.typeText
|
|
|
|
presentation = renderElement(myItems[0])
|
|
assert "(String o)" == presentation.tailText
|
|
assert "boolean" == presentation.typeText
|
|
|
|
assert !presentation.tailGrayed
|
|
assert presentation.itemTextBold
|
|
}
|
|
|
|
void testPreferLongerNamesOption() throws Exception {
|
|
configureByFile("PreferLongerNamesOption.java")
|
|
|
|
assertEquals(3, myItems.length)
|
|
assertEquals("abcdEfghIjk", myItems[0].getLookupString())
|
|
assertEquals("efghIjk", myItems[1].getLookupString())
|
|
assertEquals("ijk", myItems[2].getLookupString())
|
|
|
|
LookupManager.getInstance(getProject()).hideActiveLookup()
|
|
|
|
CodeStyleSettingsManager.getSettings(getProject()).PREFER_LONGER_NAMES = false
|
|
try{
|
|
configureByFile("PreferLongerNamesOption.java")
|
|
|
|
assertEquals(3, myItems.length)
|
|
assertEquals("ijk", myItems[0].getLookupString())
|
|
assertEquals("efghIjk", myItems[1].getLookupString())
|
|
assertEquals("abcdEfghIjk", myItems[2].getLookupString())
|
|
}
|
|
finally{
|
|
CodeStyleSettingsManager.getSettings(getProject()).PREFER_LONGER_NAMES = true
|
|
}
|
|
}
|
|
|
|
void testSCR7208() throws Exception {
|
|
configureByFile("SCR7208.java")
|
|
}
|
|
|
|
void testProtectedFromSuper() throws Exception {
|
|
configureByFile("ProtectedFromSuper.java")
|
|
Arrays.sort(myItems)
|
|
assertTrue("Exception not found", Arrays.binarySearch(myItems, "xxx") > 0)
|
|
}
|
|
|
|
void testBeforeInitialization() throws Exception {
|
|
configureByFile("BeforeInitialization.java")
|
|
assertNotNull(myItems)
|
|
assertTrue(myItems.length > 0)
|
|
}
|
|
|
|
void testProtectedFromSuper2() throws Exception {
|
|
|
|
configureByFile("ProtectedFromSuper.java")
|
|
Arrays.sort(myItems)
|
|
assertTrue("Exception not found", Arrays.binarySearch(myItems, "xxx") > 0)
|
|
}
|
|
|
|
void testClassLiteralInArrayAnnoInitializer() throws Throwable { doTest() }
|
|
|
|
void testClassLiteralInArrayAnnoInitializer2() throws Throwable { doTest() }
|
|
|
|
void testReferenceParameters() throws Exception {
|
|
configureByFile("ReferenceParameters.java")
|
|
assertNotNull(myItems)
|
|
myFixture.assertPreferredCompletionItems 0, 'AAAA', 'AAAB'
|
|
}
|
|
|
|
@Override
|
|
protected void tearDown() throws Exception {
|
|
CodeInsightSettings.instance.AUTOCOMPLETE_ON_CODE_COMPLETION = true
|
|
CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER
|
|
super.tearDown()
|
|
}
|
|
|
|
void testConstructorName1() throws Exception {
|
|
CodeInsightSettings.getInstance().AUTOCOMPLETE_ON_CODE_COMPLETION = false
|
|
configure()
|
|
assert 'ABCDE' in myFixture.lookupElementStrings
|
|
}
|
|
|
|
void testConstructorName2() throws Exception {
|
|
CodeInsightSettings.getInstance().AUTOCOMPLETE_ON_CODE_COMPLETION = false
|
|
configure()
|
|
assert 'ABCDE' in myFixture.lookupElementStrings
|
|
}
|
|
|
|
void testObjectsInThrowsBlock() throws Exception {
|
|
configureByFile("InThrowsCompletion.java")
|
|
assert "C" == myFixture.lookupElementStrings[0]
|
|
assert "B" in myFixture.lookupElementStrings
|
|
}
|
|
|
|
void testAnnoParameterValue() throws Exception {
|
|
configure()
|
|
def strings = myFixture.lookupElementStrings
|
|
assert 'AssertionError' in strings
|
|
assert !('enum' in strings)
|
|
assert !('final' in strings)
|
|
assert !('equals' in strings)
|
|
assert !('new' in strings)
|
|
assert !('null' in strings)
|
|
assert !('public' in strings)
|
|
assert !('super' in strings)
|
|
assert !('null' in strings)
|
|
}
|
|
|
|
void testAfterInstanceof() throws Exception {
|
|
configureByFile("AfterInstanceof.java")
|
|
assert "A" in myFixture.lookupElementStrings
|
|
}
|
|
|
|
void testAfterCast1() throws Exception {
|
|
configureByFile("AfterCast1.java")
|
|
|
|
assertNotNull(myItems)
|
|
assertEquals(2, myItems.length)
|
|
}
|
|
|
|
void testAfterCast2() throws Exception {
|
|
configureByFile("AfterCast2.java")
|
|
checkResultByFile("AfterCast2-result.java")
|
|
}
|
|
|
|
void testMethodCallForTwoLevelSelection() throws Exception {
|
|
configureByFile("MethodLookup.java")
|
|
assertEquals(2, myItems.length)
|
|
}
|
|
|
|
void testMethodCallBeforeAnotherStatementWithParen() throws Exception {
|
|
configureByFile("MethodLookup2.java")
|
|
checkResultByFile("MethodLookup2_After.java")
|
|
}
|
|
|
|
void testMethodCallBeforeAnotherStatementWithParen2() throws Exception {
|
|
codeStyleSettings.METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE = true
|
|
configureByFile("MethodLookup2.java")
|
|
checkResultByFile("MethodLookup2_After2.java")
|
|
}
|
|
|
|
void testSwitchEnumLabel() throws Exception {
|
|
configureByFile("SwitchEnumLabel.java")
|
|
assertEquals(3, myItems.length)
|
|
}
|
|
|
|
void testSwitchCaseWithEnumConstant() { doTest() }
|
|
|
|
void testSecondSwitchCaseWithEnumConstant() { doTest() }
|
|
|
|
void testMethodInAnnotation() throws Exception {
|
|
configureByFile("Annotation.java")
|
|
checkResultByFile("Annotation_after.java")
|
|
}
|
|
|
|
void testMethodInAnnotation2() throws Exception {
|
|
configureByFile("Annotation2.java")
|
|
checkResultByFile("Annotation2_after.java")
|
|
}
|
|
|
|
void testMethodInAnnotation3() throws Exception {
|
|
configureByFile("Annotation3.java")
|
|
checkResultByFile("Annotation3_after.java")
|
|
}
|
|
|
|
void testMethodInAnnotation5() throws Exception {
|
|
configureByFile("Annotation5.java")
|
|
checkResultByFile("Annotation5_after.java")
|
|
}
|
|
|
|
void testMethodInAnnotation7() throws Exception {
|
|
configureByFile("Annotation7.java")
|
|
selectItem(myItems[0])
|
|
checkResultByFile("Annotation7_after.java")
|
|
}
|
|
|
|
void testEnumInAnnotation() throws Exception {
|
|
configureByFile("Annotation4.java")
|
|
checkResultByFile("Annotation4_after.java")
|
|
}
|
|
|
|
void testSecondAttribute() throws Exception {
|
|
configureByFile("Annotation6.java")
|
|
checkResultByFile("Annotation6_after.java")
|
|
}
|
|
|
|
void testIDEADEV6408() throws Exception {
|
|
configureByFile("IDEADEV6408.java")
|
|
assertFirstStringItems "boolean", "byte"
|
|
}
|
|
|
|
void testMethodWithLeftParTailType() throws Exception {
|
|
configureByFile("MethodWithLeftParTailType.java")
|
|
type('(')
|
|
checkResultByFile("MethodWithLeftParTailType_after.java")
|
|
|
|
configureByFile("MethodWithLeftParTailType2.java")
|
|
type('(')
|
|
checkResultByFile("MethodWithLeftParTailType2_after.java")
|
|
}
|
|
|
|
void testSuperErasure() throws Exception {
|
|
configureByFile("SuperErasure.java")
|
|
checkResultByFile("SuperErasure_after.java")
|
|
}
|
|
|
|
void testMethodWithLeftParTailTypeNoPairBrace() throws Exception {
|
|
final boolean old = CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET
|
|
CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = false
|
|
|
|
try {
|
|
configureByFile(getTestName(false) + ".java")
|
|
type('(')
|
|
checkResult()
|
|
}
|
|
finally {
|
|
CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = old
|
|
}
|
|
}
|
|
|
|
void testMethodWithLeftParTailTypeNoPairBrace2() throws Exception {
|
|
final boolean old = CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET
|
|
CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = false
|
|
|
|
try {
|
|
//no tail type should work the normal way
|
|
configureByFile("MethodWithLeftParTailTypeNoPairBrace.java")
|
|
selectItem(myItems[0])
|
|
checkResultByFile("MethodWithLeftParTailTypeNoPairBrace_after2.java")
|
|
}
|
|
finally {
|
|
CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = old
|
|
}
|
|
}
|
|
|
|
void testMethodNoPairBrace() throws Exception {
|
|
final boolean old = CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET
|
|
CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = false
|
|
|
|
try {
|
|
doTest '\n'
|
|
}
|
|
finally {
|
|
CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET = old
|
|
}
|
|
}
|
|
|
|
void testExcessSpaceInTypeCast() throws Throwable {
|
|
configure()
|
|
selectItem(myItems[0])
|
|
checkResult()
|
|
}
|
|
|
|
void testFieldType() { doTest() }
|
|
|
|
void testPackageInAnnoParam() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testAnonymousTypeParameter() throws Throwable { doTest() }
|
|
|
|
void testClassLiteralInAnnoParam() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testNoForceBraces() {
|
|
codeStyleSettings.IF_BRACE_FORCE = CommonCodeStyleSettings.FORCE_BRACES_ALWAYS
|
|
doTest('\n')
|
|
}
|
|
|
|
void testExcludeStringBuffer() throws Throwable {
|
|
JavaProjectCodeInsightSettings.setExcludedNames(project, testRootDisposable, StringBuffer.name)
|
|
doAntiTest()
|
|
}
|
|
|
|
void testExcludeInstanceInnerClasses() throws Throwable {
|
|
JavaProjectCodeInsightSettings.setExcludedNames(project, testRootDisposable, "foo")
|
|
myFixture.addClass 'package foo; public class Outer { public class Inner {} }'
|
|
myFixture.addClass 'package bar; public class Inner {}'
|
|
configure()
|
|
assert 'bar.Inner' == ((JavaPsiClassReferenceElement)myFixture.lookupElements[0]).qualifiedName
|
|
assert myFixture.lookupElementStrings == ['Inner']
|
|
}
|
|
|
|
void testExcludedInstanceInnerClassCreation() throws Throwable {
|
|
JavaProjectCodeInsightSettings.setExcludedNames(project, testRootDisposable, "foo")
|
|
myFixture.addClass 'package foo; public class Outer { public class Inner {} }'
|
|
myFixture.addClass 'package bar; public class Inner {}'
|
|
configure()
|
|
assert 'foo.Outer.Inner' == ((JavaPsiClassReferenceElement)myFixture.lookupElements[0]).qualifiedName
|
|
assert myFixture.lookupElementStrings == ['Inner']
|
|
}
|
|
|
|
void testExcludedInstanceInnerClassQualifiedReference() throws Throwable {
|
|
JavaProjectCodeInsightSettings.setExcludedNames(project, testRootDisposable, "foo")
|
|
myFixture.addClass 'package foo; public class Outer { public class Inner {} }'
|
|
myFixture.addClass 'package bar; public class Inner {}'
|
|
configure()
|
|
assert 'foo.Outer.Inner' == ((JavaPsiClassReferenceElement)myFixture.lookupElements[0]).qualifiedName
|
|
assert myFixture.lookupElementStrings == ['Inner']
|
|
}
|
|
|
|
void testStaticMethodOfExcludedClass() {
|
|
JavaProjectCodeInsightSettings.setExcludedNames(project, testRootDisposable, "foo")
|
|
myFixture.addClass 'package foo; public class Outer { public static void method() {} }'
|
|
configure()
|
|
assert myFixture.lookupElementStrings == ['method']
|
|
}
|
|
|
|
void testExcludeWildcards() {
|
|
JavaProjectCodeInsightSettings.setExcludedNames(project, testRootDisposable, "foo.Outer.*1*")
|
|
myFixture.addClass '''
|
|
package foo;
|
|
public class Outer {
|
|
public static void method1() {}
|
|
public static void method2() {}
|
|
public static void method12() {}
|
|
public static void method42() {}
|
|
}'''
|
|
myFixture.configureByText 'a.java', 'class C {{ foo.Outer.m<caret> }}'
|
|
myFixture.completeBasic()
|
|
assert myFixture.lookupElementStrings == ['method2', 'method42']
|
|
}
|
|
|
|
void testAtUnderClass() throws Throwable {
|
|
doTest('\n')
|
|
}
|
|
|
|
void testLocalClassName() throws Throwable { doTest() }
|
|
|
|
void testAssigningFieldForTheFirstTime() throws Throwable { doTest() }
|
|
|
|
void testClassTypeParameters() throws Throwable {
|
|
configure()
|
|
assert 'K' in myFixture.lookupElementStrings
|
|
}
|
|
|
|
void testClassTypeParametersGenericBounds() throws Throwable {
|
|
configure()
|
|
assert 'K' in myFixture.lookupElementStrings
|
|
}
|
|
|
|
void testLocalClassTwice() throws Throwable {
|
|
configure()
|
|
assertOrderedEquals myFixture.lookupElementStrings, 'Zoooz', 'Zooooo'
|
|
}
|
|
|
|
void testLocalTopLevelConflict() throws Throwable {
|
|
configure()
|
|
assertOrderedEquals myFixture.lookupElementStrings, 'Zoooz', 'Zooooo'
|
|
}
|
|
|
|
void testFinalBeforeMethodCall() throws Throwable {
|
|
configure()
|
|
assertStringItems 'final', 'finalize'
|
|
}
|
|
|
|
void testMethodCallAfterFinally() { doTest() }
|
|
|
|
void testPrivateInAnonymous() throws Throwable { doTest() }
|
|
|
|
void testStaticMethodFromOuterClass() {
|
|
configure()
|
|
assertStringItems 'foo', 'A.foo', 'for'
|
|
assert LookupElementPresentation.renderElement(myItems[1]).itemText == 'A.foo'
|
|
selectItem(myItems[1])
|
|
checkResult()
|
|
}
|
|
|
|
void testInstanceMethodFromOuterClass() {
|
|
configure()
|
|
assertStringItems 'foo', 'A.this.foo', 'for'
|
|
assert LookupElementPresentation.renderElement(myItems[1]).itemText == 'A.this.foo'
|
|
selectItem(myItems[1])
|
|
checkResult()
|
|
}
|
|
|
|
void testMethodParenthesesSpaces() throws Throwable {
|
|
codeStyleSettings.SPACE_BEFORE_METHOD_CALL_PARENTHESES = true
|
|
codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
|
|
doTest()
|
|
}
|
|
|
|
void testMethodParenthesesSpacesArgs() throws Throwable {
|
|
codeStyleSettings.SPACE_BEFORE_METHOD_CALL_PARENTHESES = true
|
|
codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
|
|
doTest()
|
|
}
|
|
|
|
void testAtUnderClassNoModifiers() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testBreakInIfCondition() throws Throwable { doTest() }
|
|
|
|
void testAccessStaticViaInstance() throws Throwable { doTest() }
|
|
|
|
void testIfConditionLt() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'getAnnotationsAreaOffset'
|
|
}
|
|
|
|
void testAccessStaticViaInstanceSecond() throws Throwable {
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
checkResult()
|
|
}
|
|
|
|
void testAccessInstanceFromStaticSecond() throws Throwable {
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
checkResult()
|
|
}
|
|
|
|
void testContinueLabel() throws Throwable { doTest() }
|
|
|
|
void testAnonymousProcess() {
|
|
myFixture.addClass 'package java.lang; public class Process {}'
|
|
myFixture.addClass '''
|
|
import java.util.*;
|
|
public class Process {}
|
|
interface Pred <A> { boolean predicate(A elem); }
|
|
public class ListUtils {
|
|
public static <A> List<A> filter(List<A> list, Pred<A> pred) {}
|
|
}
|
|
'''
|
|
configure()
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testNoThisInComment() throws Throwable { doAntiTest() }
|
|
|
|
void testIncNull() throws Throwable {
|
|
configure()
|
|
checkResultByFile(getTestName(false) + ".java")
|
|
assert !('null' in myFixture.lookupElementStrings)
|
|
}
|
|
|
|
void testLastExpressionInFor() throws Throwable { doTest() }
|
|
|
|
void testOnlyKeywordsInsideSwitch() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
assertStringItems("case", "default")
|
|
}
|
|
|
|
void testBooleanLiterals() throws Throwable {
|
|
doTest('\n')
|
|
}
|
|
|
|
void testDoubleBooleanInParameter() throws Throwable {
|
|
configure()
|
|
assertFirstStringItems("boolean", "byte")
|
|
}
|
|
|
|
void testDoubleConstant() throws Throwable {
|
|
configure()
|
|
assertStringItems("XFOO")
|
|
}
|
|
|
|
void testNotOnlyKeywordsInsideSwitch() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testChainedCallOnNextLine() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
selectItem(myItems[0])
|
|
checkResult()
|
|
}
|
|
|
|
void testFinishWithDot() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
type('.')
|
|
checkResult()
|
|
}
|
|
|
|
void testEnclosingThis() throws Throwable { doTest() }
|
|
|
|
void testSeamlessConstant() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
selectItem(myItems[0])
|
|
checkResult()
|
|
}
|
|
|
|
void testDefaultAnnoParam() throws Throwable { doTest() }
|
|
|
|
void testSpaceAfterLookupString() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
type(' ')
|
|
assertNull(getLookup())
|
|
checkResult()
|
|
}
|
|
|
|
void testNoSpaceInParensWithoutParams() throws Throwable {
|
|
codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
|
|
try {
|
|
doTest()
|
|
}
|
|
finally {
|
|
codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = false
|
|
}
|
|
}
|
|
|
|
void testTwoSpacesInParensWithParams() throws Throwable {
|
|
codeStyleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES = true
|
|
doTest()
|
|
}
|
|
|
|
void testQualifierAsPackage() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
selectItem(myItems[0])
|
|
checkResult()
|
|
}
|
|
|
|
void testQualifierAsPackage2() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testQualifierAsPackage3() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testPreselectEditorSelection() {
|
|
configure()
|
|
assert lookup.currentItem != myFixture.lookupElements[0]
|
|
assert 'finalize' == lookup.currentItem.lookupString
|
|
}
|
|
|
|
void testNoMethodsInNonStaticImports() {
|
|
configure()
|
|
assertStringItems("*")
|
|
}
|
|
|
|
void testMembersInStaticImports() { doTest() }
|
|
|
|
void testPackageNamedVariableBeforeAssignment() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testInnerEnumConstant() throws Throwable { doTest('\n') }
|
|
|
|
void testNoExpectedReturnTypeDuplication() {
|
|
configure()
|
|
assert myFixture.lookupElementStrings == ['boolean', 'byte']
|
|
}
|
|
|
|
void testMethodReturnType() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testMethodReturnTypeNoSpace() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
selectItem(myItems[0])
|
|
checkResult()
|
|
}
|
|
|
|
void testEnumWithoutConstants() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testDoWhileMethodCall() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testSecondTypeParameterExtends() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testGetterWithExistingNonEmptyParameterList() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testNothingAfterNumericLiteral() throws Throwable { doAntiTest() }
|
|
|
|
void testNothingAfterTypeParameterQualifier() { doAntiTest() }
|
|
|
|
void testExcludeVariableBeingDeclared() { doAntiTest() }
|
|
|
|
void testExcludeVariableBeingDeclared2() { doAntiTest() }
|
|
|
|
void testSpacesAroundEq() throws Throwable { doTest('=') }
|
|
|
|
void _testClassBeforeCast() throws Throwable { doTest '\n' }
|
|
|
|
void testNoAllClassesOnQualifiedReference() throws Throwable {
|
|
doAntiTest()
|
|
}
|
|
|
|
void testFinishClassNameWithDot() throws Throwable {
|
|
doTest('.')
|
|
}
|
|
|
|
void testFinishClassNameWithLParen() throws Throwable {
|
|
doTest('(')
|
|
}
|
|
|
|
void testSelectNoParameterSignature() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
final int parametersCount = ((PsiMethod)getLookup().getCurrentItem().getObject()).getParameterList().getParametersCount()
|
|
assertEquals(0, parametersCount)
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testCompletionInsideClassLiteral() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testFieldNegation() throws Throwable { doTest('!') }
|
|
|
|
void testDefaultInSwitch() throws Throwable { doTest() }
|
|
|
|
void testBreakInSwitch() throws Throwable { doTest() }
|
|
|
|
void testSuperInConstructor() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testSuperInConstructorWithParams() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testSuperInMethod() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testSecondMethodParameterName() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testAnnotationAsUsualObject() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testAnnotationAsUsualObjectFromJavadoc() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testAnnotationAsUsualObjectInsideClass() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testAnnotationOnNothingParens() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testMultiResolveQualifier() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testSecondMethodParameter() throws Throwable { doTest() }
|
|
|
|
void testReturnInCase() throws Throwable { doTest() }
|
|
|
|
void testUnboxedConstantsInCase() throws Throwable { doTest() }
|
|
|
|
void testAnnotationWithoutValueMethod() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
assertStringItems("bar", "foo")
|
|
}
|
|
|
|
void testAddExplicitValueInAnnotation() throws Throwable {
|
|
configureByTestName()
|
|
assertStringItems("bar", "goo")
|
|
selectItem(myItems[0])
|
|
checkResult()
|
|
}
|
|
|
|
void testUnnecessaryMethodMerging() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
assertStringItems("fofoo", "fofoo")
|
|
}
|
|
|
|
void testMethodMergingMinimalTail() { doTest() }
|
|
|
|
void testAnnotationQualifiedName() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testClassNameGenerics() throws Throwable {
|
|
doTest('\n')
|
|
}
|
|
|
|
void testClassNameAnonymous() throws Throwable {
|
|
doTest('\n')
|
|
}
|
|
|
|
void testClassNameWithInner() throws Throwable {
|
|
configure()
|
|
assertStringItems 'Zzoo', 'Zzoo.Impl'
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testClassNameWithInner2() throws Throwable { doTest('\n') }
|
|
|
|
void testClassNameWithInstanceInner() throws Throwable { doTest('\n') }
|
|
|
|
void testDoubleFalse() throws Throwable {
|
|
configureByFile(getTestName(false) + ".java")
|
|
assertFirstStringItems("false", "fefefef", "float", "finalize")
|
|
}
|
|
|
|
void testSameNamedVariableInNestedClasses() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testHonorUnderscoreInPrefix() throws Throwable {
|
|
doTest()
|
|
}
|
|
|
|
void testNoSemicolonAfterExistingParenthesesEspeciallyIfItsACast() throws Throwable { doTest() }
|
|
|
|
void testReturningTypeVariable() throws Throwable { doTest() }
|
|
|
|
void testReturningTypeVariable2() throws Throwable { doTest() }
|
|
|
|
void testReturningTypeVariable3() throws Throwable { doTest() }
|
|
|
|
void testImportInGenericType() throws Throwable {
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
myFixture.type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testCaseTailType() throws Throwable { doTest() }
|
|
|
|
def doPrimitiveTypeTest() {
|
|
configure()
|
|
checkResultByFile(getTestName(false) + ".java")
|
|
assertTrue 'boolean' in myFixture.lookupElementStrings
|
|
}
|
|
|
|
private def configure() {
|
|
configureByTestName()
|
|
}
|
|
|
|
void testFinalInForLoop() throws Throwable {
|
|
configure()
|
|
assertStringItems 'final'
|
|
}
|
|
|
|
void testFinalInForLoop2() throws Throwable {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'finalize', 'final'
|
|
}
|
|
|
|
void testOnlyClassesInExtends() throws Throwable {
|
|
configure()
|
|
assertStringItems 'Inner'
|
|
}
|
|
|
|
void testNoThisClassInExtends() throws Throwable {
|
|
configure()
|
|
assertStringItems 'Fooxxxx2'
|
|
}
|
|
|
|
void testPrimitiveTypesInForLoop() throws Throwable { doPrimitiveTypeTest() }
|
|
|
|
void testPrimitiveTypesInForLoop2() throws Throwable { doPrimitiveTypeTest() }
|
|
|
|
void testPrimitiveTypesInForLoop3() throws Throwable { doPrimitiveTypeTest() }
|
|
|
|
void testPrimitiveTypesInForLoop4() throws Throwable { doPrimitiveTypeTest() }
|
|
|
|
void testPrimitiveTypesInForLoop5() throws Throwable { doPrimitiveTypeTest() }
|
|
|
|
void testPrimitiveTypesInForLoop6() throws Throwable { doPrimitiveTypeTest() }
|
|
|
|
void testPrimitiveTypesInForLoopSpace() throws Throwable {
|
|
configure()
|
|
myFixture.type ' '
|
|
checkResultByFile(getTestName(false) + "_after.java")
|
|
}
|
|
|
|
void testSuggestInaccessibleOnSecondInvocation() throws Throwable {
|
|
configure()
|
|
assertStringItems("_bar", "_goo")
|
|
complete()
|
|
assertStringItems("_bar", "_goo", "_foo")
|
|
getLookup().setCurrentItem(getLookup().getItems().get(2))
|
|
selectItem(lookup.items[2], Lookup.NORMAL_SELECT_CHAR)
|
|
checkResult()
|
|
}
|
|
|
|
void testNoCommonPrefixInsideIdentifier() throws Throwable {
|
|
final String path = getTestName(false) + ".java"
|
|
configureByFile(path)
|
|
checkResultByFile(path)
|
|
assertStringItems("fai1", "fai2")
|
|
}
|
|
|
|
void testProtectedInaccessibleOnSecondInvocation() throws Throwable {
|
|
myFixture.configureByFile(getTestName(false) + ".java")
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
myFixture.type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testPropertyReferencePrefix() throws Throwable {
|
|
myFixture.addFileToProject("test.properties", "foo.bar=Foo! Bar!").getVirtualFile()
|
|
doAntiTest()
|
|
}
|
|
|
|
private void doTest() throws Exception {
|
|
configure()
|
|
checkResult()
|
|
}
|
|
|
|
private void doTest(String finishChar) throws Exception {
|
|
configure()
|
|
type finishChar
|
|
checkResult()
|
|
}
|
|
|
|
void testSecondAnonymousClassParameter() { doTest() }
|
|
|
|
void testSpaceAfterReturn() throws Throwable {
|
|
configure()
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
private def checkResult() {
|
|
checkResultByFile(getTestName(false) + "_after.java")
|
|
}
|
|
|
|
void testIntersectionTypeMembers() throws Throwable {
|
|
configure()
|
|
assertStringItems "fooa", "foob"
|
|
}
|
|
|
|
void testNoReturnInTernary() throws Throwable { doTest() }
|
|
|
|
void testWildcardsInLookup() throws Exception {
|
|
configure()
|
|
assertNotNull(getLookup())
|
|
type('*fz')
|
|
assert !lookup
|
|
}
|
|
|
|
void testSmartEnterWrapsConstructorCall() throws Throwable { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
|
|
|
|
void testSmartEnterNoNewLine() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
|
|
|
|
void testSmartEnterWithNewLine() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
|
|
|
|
void testSmartEnterGuessArgumentCount() throws Throwable { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
|
|
|
|
void testSmartEnterInsideArrayBrackets() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
|
|
|
|
void testTabReplacesMethodNameWithLocalVariableName() throws Throwable { doTest('\t') }
|
|
|
|
void testMethodParameterAnnotationClass() throws Throwable { doTest() }
|
|
|
|
void testInnerAnnotation() { doTest('\n') }
|
|
|
|
void testPrimitiveCastOverwrite() throws Throwable { doTest() }
|
|
|
|
void testClassReferenceInFor() throws Throwable { doTest ' ' }
|
|
|
|
void testClassReferenceInFor2() throws Throwable { doTest ' ' }
|
|
|
|
void testClassReferenceInFor3() throws Throwable {
|
|
CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
|
|
doTest ' '
|
|
}
|
|
|
|
void testEnumConstantFromEnumMember() throws Throwable { doTest() }
|
|
|
|
void testPrimitiveMethodParameter() throws Throwable { doTest() }
|
|
|
|
void testNewExpectedClassParens() throws Throwable { doTest('\n') }
|
|
|
|
void testQualifyInnerMembers() throws Throwable { doTest('\n') }
|
|
|
|
void testDeepInner() throws Throwable {
|
|
configure()
|
|
assert myFixture.lookupElementStrings == ['ClassInner1', 'ClassInner1.ClassInner2']
|
|
selectItem(lookup.items[1])
|
|
checkResult()
|
|
}
|
|
|
|
void testSuggestExpectedTypeMembers() throws Throwable { doTest('\n') }
|
|
|
|
void testSuggestExpectedTypeMembersInCall() throws Throwable { doTest('\n') }
|
|
|
|
void testSuggestExpectedTypeMembersInAnno() throws Throwable { doTest('\n') }
|
|
|
|
void testExpectedTypesDotSelectsItem() throws Throwable { doTest('.') }
|
|
|
|
void testExpectedTypeMembersVersusStaticImports() throws Throwable {
|
|
configure()
|
|
assertStringItems('XFOO', 'XFOX')
|
|
}
|
|
|
|
void testDoubleExpectedTypeFactoryMethod() throws Throwable {
|
|
configure()
|
|
assertStringItems('Key', 'create', 'create')
|
|
assert renderElement(myItems[1]).itemText == 'Key.<Boolean>create'
|
|
assert renderElement(myItems[2]).itemText == 'Key.create'
|
|
}
|
|
|
|
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')
|
|
}
|
|
|
|
void testStaticallyImportedInner() throws Throwable {
|
|
configure()
|
|
assertStringItems('AIOInner', 'ArrayIndexOutOfBoundsException')
|
|
}
|
|
|
|
void testClassNameInIfBeforeIdentifier() throws Throwable {
|
|
myFixture.addClass("public class ABCDEFFFFF {}")
|
|
doTest('\n')
|
|
}
|
|
|
|
void testClassNameWithInnersTab() throws Throwable { doTest('\t') }
|
|
|
|
void testClassNameWithGenericsTab() throws Throwable { doTest('\t') }
|
|
|
|
void testClassNameWithGenericsTab2() throws Throwable { doTest('\t') }
|
|
|
|
void testLiveTemplatePrefixTab() throws Throwable { doTest('\t') }
|
|
|
|
void testOnlyAnnotationsAfterAt() throws Throwable { doTest() }
|
|
|
|
void testOnlyAnnotationsAfterAt2() throws Throwable { doTest('\n') }
|
|
|
|
void testAnnotationBeforeIdentifier() { doTest('\n') }
|
|
|
|
void testAnnotationBeforeQualifiedReference() { doTest('\n') }
|
|
|
|
void testAnnotationBeforeIdentifierFinishWithSpace() { doTest(' ') }
|
|
|
|
void testOnlyExceptionsInCatch1() throws Exception { doTest('\n') }
|
|
|
|
void testOnlyExceptionsInCatch2() throws Exception { doTest('\n') }
|
|
|
|
void testOnlyExceptionsInCatch3() throws Exception { doTest('\n') }
|
|
|
|
void testOnlyExceptionsInCatch4() throws Exception { doTest('\n') }
|
|
|
|
void testCommaAfterVariable() throws Throwable { doTest(',') }
|
|
|
|
void testClassAngleBracket() throws Throwable { doTest('<') }
|
|
|
|
void testNoArgsMethodSpace() throws Throwable { doTest(' ') }
|
|
|
|
void testClassSquareBracket() throws Throwable { doTest('[') }
|
|
|
|
void testPrimitiveSquareBracket() throws Throwable { doTest('[') }
|
|
|
|
void testVariableSquareBracket() throws Throwable { doTest('[') }
|
|
|
|
void testMethodSquareBracket() throws Throwable { doTest('[') }
|
|
|
|
void testMethodParameterTypeDot() throws Throwable { doAntiTest() }
|
|
|
|
void testNewGenericClass() throws Throwable { doTest('\n') }
|
|
|
|
void testNewGenericInterface() throws Throwable { doTest() }
|
|
|
|
void testEnumPrivateFinal() throws Throwable { doTest() }
|
|
|
|
void testNoFieldsInImplements() throws Throwable { doTest() }
|
|
|
|
void testSwitchConstantsFromReferencedClass() throws Throwable { doTest('\n') }
|
|
|
|
void testSwitchValueFinishWithColon() throws Throwable { doTest(':') }
|
|
|
|
void testUnfinishedMethodTypeParameter() throws Throwable {
|
|
configure()
|
|
assertStringItems("MyParameter", "MySecondParameter")
|
|
}
|
|
|
|
void testUnfinishedMethodTypeParameter2() throws Throwable {
|
|
configure()
|
|
assertStringItems("MyParameter", "MySecondParameter")
|
|
}
|
|
|
|
void testSuperProtectedMethod() throws Throwable {
|
|
myFixture.addClass """package foo;
|
|
public class Bar {
|
|
protected void foo() { }
|
|
}"""
|
|
doTest()
|
|
}
|
|
|
|
void testOuterSuperMethodCall() {
|
|
configure()
|
|
assert 'Class2.super.put' == LookupElementPresentation.renderElement(myItems[0]).itemText
|
|
type '\n'
|
|
checkResult() }
|
|
|
|
void testTopLevelClassesFromPackaged() throws Throwable {
|
|
myFixture.addClass "public class Fooooo {}"
|
|
final text = "package foo; class Bar { Fooo<caret> }"
|
|
def file = myFixture.addFileToProject("foo/Bar.java", text)
|
|
myFixture.configureFromExistingVirtualFile file.virtualFile
|
|
assertEmpty myFixture.completeBasic()
|
|
myFixture.checkResult text
|
|
}
|
|
|
|
void testRightShift() throws Throwable {
|
|
configure()
|
|
assertStringItems("myField1", "myField2")
|
|
}
|
|
|
|
void testAfterCommonPrefix() throws Throwable {
|
|
configure()
|
|
type 'eq'
|
|
assertFirstStringItems("equals", "equalsIgnoreCase")
|
|
complete()
|
|
assertFirstStringItems("equals", "equalsIgnoreCase")
|
|
type '('
|
|
checkResult()
|
|
}
|
|
|
|
void testClassNameInsideIdentifierInIf() throws Throwable {
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testKeywordSmartEnter() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'null', 'nullity'
|
|
myFixture.performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM_COMPLETE_STATEMENT)
|
|
checkResult()
|
|
}
|
|
void testSynchronizedArgumentSmartEnter() { doTest(Lookup.COMPLETE_STATEMENT_SELECT_CHAR as String) }
|
|
|
|
void testImportStringValue() throws Throwable {
|
|
myFixture.addClass("package foo; public class StringValue {}")
|
|
myFixture.addClass("package java.lang; class StringValue {}")
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
type ' '
|
|
checkResult()
|
|
}
|
|
|
|
void testPrimitiveArrayWithRBrace() throws Throwable { doTest '[' }
|
|
|
|
void testSuggestMembersOfStaticallyImportedClasses() throws Exception {
|
|
myFixture.addClass("""package foo;
|
|
public class Foo {
|
|
public static void foo() {}
|
|
public static void bar() {}
|
|
}
|
|
""")
|
|
doTest('\n')
|
|
}
|
|
|
|
void testSuggestMembersOfStaticallyImportedClassesUnqualifiedOnly() throws Exception {
|
|
myFixture.addClass("""package foo;
|
|
public class Foo {
|
|
public static void foo() {}
|
|
public static void bar() {}
|
|
}
|
|
""")
|
|
configure()
|
|
complete()
|
|
assertOneElement(myFixture.getLookupElements())
|
|
myFixture.type '\t'
|
|
checkResult()
|
|
}
|
|
|
|
void testSuggestMembersOfStaticallyImportedClassesConflictWithLocalMethod() throws Exception {
|
|
myFixture.addClass("""package foo;
|
|
public class Foo {
|
|
public static void foo() {}
|
|
public static void bar() {}
|
|
}
|
|
""")
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'bar', 'bar'
|
|
assert LookupElementPresentation.renderElement(myFixture.lookupElements[1]).itemText == 'Foo.bar'
|
|
myFixture.lookup.currentItem = myFixture.lookupElements[1]
|
|
myFixture.type '\t'
|
|
checkResult()
|
|
}
|
|
|
|
void testSuggestMembersOfStaticallyImportedClassesConflictWithLocalField() throws Exception {
|
|
myFixture.addClass("""package foo;
|
|
public class Foo {
|
|
public static int foo = 1;
|
|
public static int bar = 2;
|
|
}
|
|
""")
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'bar', 'Foo.bar'
|
|
myFixture.lookup.currentItem = myFixture.lookupElements[1]
|
|
myFixture.type '\t'
|
|
checkResult()
|
|
}
|
|
|
|
void testInstanceMagicMethod() throws Exception { doTest() }
|
|
|
|
void testNoDotOverwrite() throws Exception { doTest('.') }
|
|
|
|
void testStaticInnerExtendingOuter() throws Exception { doTest() }
|
|
|
|
void testPrimitiveClass() throws Exception { doTest() }
|
|
|
|
void testPrimitiveArrayClass() throws Exception { doTest() }
|
|
|
|
void testPrimitiveArrayOnlyClass() throws Exception { doAntiTest() }
|
|
|
|
void testPrimitiveArrayInAnno() throws Exception { doTest() }
|
|
|
|
void testNewClassAngleBracket() throws Exception { doTest('<') }
|
|
|
|
void testNewClassAngleBracketExpected() throws Exception { doTest('<') }
|
|
|
|
void testNewClassSquareBracket() throws Exception { doTest('[') }
|
|
|
|
void testMethodColon() throws Exception { doTest(':') }
|
|
|
|
void testVariableColon() throws Exception { doTest(':') }
|
|
|
|
void testFinishByClosingParenthesis() throws Exception { doTest(')') }
|
|
|
|
void testNoMethodsInParameterType() {
|
|
configure()
|
|
assertFirstStringItems "final", "float"
|
|
}
|
|
|
|
void testNonImportedClassInAnnotation() {
|
|
myFixture.addClass("package foo; public class XInternalTimerServiceController {}")
|
|
myFixture.configureByText "a.java", """
|
|
class XInternalError {}
|
|
|
|
@Anno(XInternal<caret>)
|
|
"""
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
assertFirstStringItems "XInternalError", "XInternalTimerServiceController"
|
|
}
|
|
|
|
void testNonImportedAnnotationClass() {
|
|
myFixture.addClass("package foo; public @interface XAnotherAnno {}")
|
|
configure()
|
|
type('X')
|
|
assertFirstStringItems "XAnno", "XAnotherAnno"
|
|
}
|
|
|
|
void testMetaAnnotation() {
|
|
myFixture.configureByText "a.java", "@<caret> @interface Anno {}"
|
|
myFixture.complete(CompletionType.BASIC)
|
|
assert myFixture.lookup.items.find { it.lookupString == 'Retention' }
|
|
}
|
|
|
|
void testAnnotationClassFromWithinAnnotation() { doTest() }
|
|
|
|
void testStaticallyImportedFieldsTwice() {
|
|
myFixture.addClass("""
|
|
class Foo {
|
|
public static final int aZOO;
|
|
}
|
|
""")
|
|
myFixture.configureByText("a.java", """
|
|
import static Foo.*
|
|
class Bar {{
|
|
aZ<caret>a
|
|
}}
|
|
""")
|
|
assertOneElement myFixture.completeBasic()
|
|
}
|
|
|
|
void testStaticallyImportedFieldsTwiceSwitch() { doTest() }
|
|
|
|
void testStatementKeywords() {
|
|
myFixture.configureByText("a.java", """
|
|
class Bar {{
|
|
<caret>xxx
|
|
}}
|
|
""")
|
|
myFixture.completeBasic()
|
|
final def strings = myFixture.lookupElementStrings
|
|
assertTrue 'if' in strings
|
|
assertTrue 'while' in strings
|
|
assertTrue 'do' in strings
|
|
assertTrue 'new' in strings
|
|
assertTrue 'try' in strings
|
|
|
|
strings.remove 'new'
|
|
assertFalse 'new' in strings
|
|
}
|
|
|
|
void testExpressionKeywords() {
|
|
myFixture.configureByText("a.java", """
|
|
class Bar {{
|
|
foo(<caret>xxx)
|
|
}}
|
|
""")
|
|
myFixture.completeBasic()
|
|
final def strings = myFixture.lookupElementStrings
|
|
assertTrue 'new' in strings
|
|
}
|
|
|
|
void testImportAsterisk() {
|
|
myFixture.configureByText "a.java", "import java.lang.<caret>"
|
|
myFixture.completeBasic()
|
|
myFixture.type '*;'
|
|
myFixture.checkResult "import java.lang.*;<caret>"
|
|
}
|
|
|
|
void testDontPreselectCaseInsensitivePrefixMatch() {
|
|
CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
|
|
myFixture.configureByText "a.java", "import java.io.*; class Foo {{ int fileSize; fil<caret>x }}"
|
|
myFixture.completeBasic()
|
|
assert lookup.currentItem.lookupString == 'fileSize'
|
|
myFixture.type('e')
|
|
|
|
assert lookup.items[0].lookupString == 'File'
|
|
assert lookup.items[1].lookupString == 'fileSize'
|
|
assert lookup.currentItem == lookup.items[1]
|
|
}
|
|
|
|
void testNoGenericsWhenChoosingWithParen() { doTest('Ma(') }
|
|
|
|
void testNoClosingWhenChoosingWithParenBeforeIdentifier() { doTest '(' }
|
|
|
|
void testPackageInMemberType() { doTest() }
|
|
|
|
void testConstantInAnno() { doTest() }
|
|
|
|
void testCharsetName() {
|
|
myFixture.addClass("package java.nio.charset; public class Charset { public static Charset forName(String s) {} }")
|
|
configureByTestName()
|
|
assert myFixture.lookupElementStrings.contains('UTF-8')
|
|
}
|
|
|
|
void testInnerClassInExtendsGenerics() {
|
|
def text = "package bar; class Foo extends List<Inne<caret>> { public static class Inner {} }"
|
|
myFixture.configureFromExistingVirtualFile(myFixture.addClass(text).containingFile.virtualFile)
|
|
myFixture.completeBasic()
|
|
myFixture.type('\n')
|
|
myFixture.checkResult(text.replace('Inne<caret>', 'Foo.Inner<caret>'))
|
|
}
|
|
|
|
void testClassNameDot() { doTest('.') }
|
|
|
|
void testClassNameDotBeforeCall() {
|
|
myFixture.addClass("package foo; public class FileInputStreamSmth {}")
|
|
myFixture.configureByFile(getTestName(false) + ".java")
|
|
PsiDocumentManager.getInstance(project).commitAllDocuments()
|
|
type '\b'
|
|
PsiDocumentManager.getInstance(project).commitAllDocuments()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
assert lookup
|
|
type '.'
|
|
checkResult()
|
|
}
|
|
|
|
void testNoReturnAfterDot() {
|
|
configure()
|
|
assert !('return' in myFixture.lookupElementStrings)
|
|
}
|
|
|
|
void testDuplicateExpectedTypeInTypeArgumentList() {
|
|
configure()
|
|
def items = myFixture.lookupElements.findAll { it.lookupString == 'String' }
|
|
assert items.size() == 1
|
|
assert LookupElementPresentation.renderElement(items[0]).tailText == ' (java.lang)'
|
|
}
|
|
|
|
void testDuplicateInnerClass() {
|
|
configure()
|
|
def items = myFixture.lookupElements.findAll { it.lookupString == 'Inner' }
|
|
assert items.size() == 1
|
|
}
|
|
|
|
void testSameSignature() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems(0, 's', 's, file', 's, file, a')
|
|
lookup.setCurrentItem(lookup.items[2])
|
|
myFixture.type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testNoParenthesesAroundCallQualifier() { doTest() }
|
|
|
|
void testAllAssertClassesMethods() {
|
|
myFixture.addClass 'package foo; public class Assert { public static boolean foo() {} }'
|
|
myFixture.addClass 'package bar; public class Assert { public static boolean bar() {} }'
|
|
configure()
|
|
assert myFixture.lookupElementStrings == ['Assert.bar', 'Assert.foo']
|
|
myFixture.type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testCastVisually() {
|
|
configure()
|
|
def p = LookupElementPresentation.renderElement(myFixture.lookupElements[0])
|
|
assert p.itemText == 'getValue'
|
|
assert p.itemTextBold
|
|
assert p.typeText == 'Foo'
|
|
}
|
|
|
|
void testSuggestEmptySet() {
|
|
configure()
|
|
assert 'emptySet' == myFixture.lookupElementStrings[0]
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testSuggestAllTypeArguments() {
|
|
configure()
|
|
assert 'String, List<String>' == lookup.items[0].lookupString
|
|
assert 'String, List<String>' == LookupElementPresentation.renderElement(lookup.items[0]).itemText
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testMakeMultipleArgumentsFinalWhenInInner() {
|
|
configure()
|
|
def item = lookup.items.find { 'a, b' == it.lookupString }
|
|
assert item
|
|
lookup.currentItem = item
|
|
type '\n'
|
|
checkResult()
|
|
}
|
|
|
|
void testNoFinalInAnonymousConstructor() { doTest() }
|
|
|
|
void testListArrayListCast() { doTest('\n') }
|
|
|
|
void testInterfaceImplementationNoCast() { doTest() }
|
|
|
|
void testStaticallyImportedMethodsBeforeExpression() { doTest() }
|
|
|
|
void testInnerChainedReturnType() { doTest() }
|
|
|
|
void testOverwriteGenericsAfterNew() { doTest('\n') }
|
|
|
|
private CommonCodeStyleSettings getCodeStyleSettings() {
|
|
return CodeStyleSettingsManager.getSettings(getProject()).getCommonSettings(JavaLanguage.INSTANCE)
|
|
}
|
|
|
|
void testCompatibleInterfacesCast() {
|
|
configure()
|
|
assert myFixture.lookupElementStrings.containsAll(['foo', 'bar'])
|
|
}
|
|
|
|
void testDontAutoInsertMiddleMatch() {
|
|
configure()
|
|
checkResult()
|
|
assert lookup.items.size() == 1
|
|
}
|
|
|
|
void testImplementViaCompletion() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'private', 'protected', 'public', 'public void run'
|
|
def item = lookup.items[3]
|
|
|
|
def p = LookupElementPresentation.renderElement(item)
|
|
assert p.itemText == 'public void run'
|
|
assert p.tailText == '(t, myInt) {...}'
|
|
assert p.typeText == 'Foo'
|
|
|
|
lookup.currentItem = item
|
|
myFixture.type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testImplementViaOverrideCompletion() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'Override', 'public void run'
|
|
lookup.currentItem = lookup.items[1]
|
|
myFixture.type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testStrikeOutDeprecatedSuperMethods() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, 'void foo1', 'void foo2'
|
|
assert !LookupElementPresentation.renderElement(lookup.items[0]).strikeout
|
|
assert LookupElementPresentation.renderElement(lookup.items[1]).strikeout
|
|
}
|
|
|
|
void testAccessorViaCompletion() {
|
|
configure()
|
|
|
|
def getter = myFixture.lookupElements.find { it.lookupString == 'public int getField' }
|
|
def setter = myFixture.lookupElements.find { it.lookupString == 'public void setField' }
|
|
assert getter : myFixture.lookupElementStrings
|
|
assert setter : myFixture.lookupElementStrings
|
|
|
|
def p = LookupElementPresentation.renderElement(getter)
|
|
assert p.itemText == getter.lookupString
|
|
assert p.tailText == '() {...}'
|
|
assert !p.typeText
|
|
|
|
p = LookupElementPresentation.renderElement(setter)
|
|
assert p.itemText == setter.lookupString
|
|
assert p.tailText == '(field) {...}'
|
|
assert !p.typeText
|
|
|
|
lookup.currentItem = getter
|
|
myFixture.type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testBraceOnNextLine() {
|
|
codeStyleSettings.BRACE_STYLE = CommonCodeStyleSettings.NEXT_LINE
|
|
doTest()
|
|
}
|
|
|
|
void testDoForceBraces() {
|
|
codeStyleSettings.DOWHILE_BRACE_FORCE = CommonCodeStyleSettings.FORCE_BRACES_ALWAYS
|
|
doTest('\n')
|
|
}
|
|
|
|
void testMulticaretSingleItemInsertion() {
|
|
doTest()
|
|
}
|
|
|
|
void testMulticaretMethodWithParen() {
|
|
doTest()
|
|
}
|
|
|
|
void testMulticaretTyping() {
|
|
configure()
|
|
assert lookup
|
|
type('p')
|
|
assert lookup
|
|
type('\n')
|
|
checkResult()
|
|
}
|
|
|
|
void testMulticaretCompletionFromNonPrimaryCaret() {
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems(0, "arraycopy")
|
|
}
|
|
|
|
void testMulticaretCompletionFromNonPrimaryCaretWithTab() {
|
|
doTest '\t'
|
|
}
|
|
|
|
void "test complete lowercase class name"() {
|
|
myFixture.addClass("package foo; public class myClass {}")
|
|
myFixture.configureByText "a.java", """
|
|
class Foo extends my<caret>
|
|
"""
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
myFixture.checkResult '''import foo.myClass;
|
|
|
|
class Foo extends myClass
|
|
'''
|
|
}
|
|
|
|
void "test don't show static inner class after instance qualifier"() {
|
|
myFixture.configureByText "a.java", """
|
|
class Foo {
|
|
static class Inner {}
|
|
}
|
|
class Bar {
|
|
void foo(Foo f) {
|
|
f.<caret>
|
|
}
|
|
}
|
|
"""
|
|
myFixture.completeBasic()
|
|
assert !('Inner' in myFixture.lookupElementStrings)
|
|
}
|
|
|
|
void "test show static member after instance qualifier when nothing matches"() {
|
|
myFixture.configureByText "a.java", "class Foo{{ \"\".<caret> }}"
|
|
myFixture.completeBasic()
|
|
assert !('valueOf' in myFixture.lookupElementStrings)
|
|
((LookupImpl)myFixture.lookup).hide()
|
|
myFixture.type 'val'
|
|
myFixture.completeBasic()
|
|
assert ('valueOf' in myFixture.lookupElementStrings)
|
|
}
|
|
|
|
void testNoMathTargetMethods() { doAntiTest() }
|
|
|
|
void testNoLowercaseClasses() {
|
|
myFixture.addClass("package foo; public class abcdefgXxx {}")
|
|
doAntiTest()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
assertStringItems('abcdefgXxx')
|
|
}
|
|
|
|
void testProtectedFieldInAnotherPackage() {
|
|
myFixture.addClass("package foo; public class Super { protected String myString; }")
|
|
doTest()
|
|
}
|
|
|
|
void testUnimportedStaticInnerClass() {
|
|
myFixture.addClass("package foo; public class Super { public static class Inner {} }")
|
|
doTest()
|
|
}
|
|
|
|
void testNoJavaLangPackagesInImport() { doAntiTest() }
|
|
|
|
void testNoStaticDuplicatesFromExpectedMemberFactories() {
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
myFixture.assertPreferredCompletionItems(0, "xcreateZoo", "xcreateElephant")
|
|
}
|
|
|
|
void testNoInaccessibleCompiledElements() {
|
|
configure()
|
|
myFixture.complete(CompletionType.BASIC, 2)
|
|
checkResultByFile(getTestName(false) + ".java")
|
|
assertEmpty(myItems)
|
|
assertNull(getLookup())
|
|
}
|
|
|
|
void "test code cleanup during completion generation"() {
|
|
myFixture.configureByText "a.java", "class Foo {int i; ge<caret>}"
|
|
myFixture.enableInspections(new UnqualifiedFieldAccessInspection())
|
|
myFixture.complete(CompletionType.BASIC)
|
|
UIUtil.dispatchAllInvocationEvents()
|
|
myFixture.checkResult '''class Foo {int i;
|
|
|
|
public int getI() {
|
|
return this.i;
|
|
}
|
|
}'''
|
|
}
|
|
|
|
void testIndentingForSwitchCase() { doTest() }
|
|
|
|
void testIncrementalCopyReparse() {
|
|
((PsiDocumentManagerBase)PsiDocumentManager.getInstance(project)).disableBackgroundCommit(testRootDisposable)
|
|
|
|
myFixture.configureByText('a.java', 'class Fooxxxxxxxxxx { Fooxxxxx<caret>a f;\n' + 'public void foo() {}\n' * 10000 + '}')
|
|
def items = myFixture.completeBasic()
|
|
PsiClass c1 = items[0].object
|
|
assert !c1.physical
|
|
assert CompletionUtil.getOriginalElement(c1)
|
|
|
|
getLookup().hide()
|
|
myFixture.type('x')
|
|
items = myFixture.completeBasic()
|
|
PsiClass c2 = items[0].object
|
|
assert !c2.physical
|
|
assert CompletionUtil.getOriginalElement(c2)
|
|
|
|
assert c1.is(c2)
|
|
}
|
|
|
|
void testShowMostSpecificOverride() {
|
|
configure()
|
|
assert 'B' == LookupElementPresentation.renderElement(myFixture.lookup.items[0]).typeText
|
|
}
|
|
|
|
void testShowVarInitializers() {
|
|
configure()
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[0]).tailText == '( "x")'
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[1]).tailText == '("y") {...}'
|
|
assert !LookupElementPresentation.renderElement(myFixture.lookup.items[2]).tailText
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[3]).tailText == ' ( = 42)'
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[3]).tailFragments[0].italic
|
|
}
|
|
|
|
void testSuggestInterfaceArrayWhenObjectIsExpected() {
|
|
configure()
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[0]).tailText.contains('{...}')
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[1]).tailText.contains('[]')
|
|
}
|
|
|
|
void testSuggestInterfaceArrayWhenObjectArrayIsExpected() {
|
|
configure()
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[0]).tailText.contains('{...}')
|
|
assert LookupElementPresentation.renderElement(myFixture.lookup.items[1]).tailText.contains('[]')
|
|
}
|
|
|
|
void testDispreferPrimitiveTypesInCallArgs() throws Throwable {
|
|
CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
|
|
configure()
|
|
myFixture.assertPreferredCompletionItems 0, "dx", "doo", "Doo", "double"
|
|
}
|
|
|
|
void testCopyConstructor() { doTest('\n') }
|
|
|
|
void testGetClassType() {
|
|
configure()
|
|
assert 'Class<? extends Number>' == LookupElementPresentation.renderElement(myFixture.lookupElements[0]).typeText
|
|
}
|
|
|
|
void testNonImportedClassAfterNew() {
|
|
def uClass = myFixture.addClass('package foo; public class U {}')
|
|
myFixture.configureByText('a.java', 'class X {{ new U<caret>x }}')
|
|
myFixture.completeBasic()
|
|
assert myFixture.lookupElements[0].object == uClass
|
|
}
|
|
|
|
void testSuggestClassNamesForLambdaParameterTypes() { doTest('\n') }
|
|
|
|
void testOnlyExtendsSuperInWildcard() {
|
|
CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
|
|
|
|
configure()
|
|
assert myFixture.lookupElementStrings == ['extends', 'super']
|
|
LookupManager.getInstance(project).hideActiveLookup()
|
|
|
|
myFixture.type('n')
|
|
assert !myFixture.completeBasic()
|
|
myFixture.type('\b')
|
|
checkResultByFile(getTestName(false) + ".java")
|
|
}
|
|
|
|
}
|