plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *  http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  */
  16
  17 package org.jetbrains.plugins.groovy.completion;
  18
  19
  20 import com.intellij.codeInsight.CodeInsightSettings
  21 import com.intellij.codeInsight.lookup.LookupElement
  22 import com.intellij.codeInsight.lookup.LookupElementPresentation
  23 import org.jetbrains.plugins.groovy.GroovyFileType
  24 import org.jetbrains.plugins.groovy.util.TestUtils
  25 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
  26 import org.jetbrains.plugins.groovy.formatter.GroovyCodeStyleSettings
  27 import com.intellij.codeInsight.completion.CompletionType
  28
  29 /**
  30  * @author Maxim.Medvedev
  31  */
  32 public class GroovyCompletionTest extends GroovyCompletionTestBase {
  33   @Override
  34   protected String getBasePath() {
  35     return TestUtils.getTestDataPath() + "groovy/completion/";
  36   }
  37
  38   @Override
  39   protected void tearDown() {
  40     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.FIRST_LETTER
  41     super.tearDown()
  42   }
  43
  44   public void testFinishMethodWithLParen() throws Throwable {
  45     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "getBar", "getClass", "getFoo");
  46     myFixture.type('(');
  47     myFixture.checkResultByFile(getTestName(false) + "_after.groovy");
  48   }
  49
  50   public void testNamedParametersForApplication() throws Throwable {
  51     doVariantableTest("abx", "aby");
  52   }
  53
  54   public void testNamedParametersForMethodCall() throws Throwable {
  55     doVariantableTest("abx", "aby");
  56   }
  57
  58   public void testNamedParameters1() throws Throwable {
  59     doVariantableTest("abx", "aby");
  60   }
  61
  62   public void testNamedParameters2() throws Throwable {
  63     doVariantableTest("abx", "aby");
  64   }
  65
  66   public void testNamedParametersInMap1() throws Throwable {
  67     doVariantableTest("abx", "aby");
  68   }
  69
  70   public void testNamedParametersInMap2() throws Throwable {
  71     doVariantableTest("abx", "aby");
  72   }
  73
  74   public void testNamedParametersInSecondMap1() throws Throwable {
  75     doVariantableTest();
  76   }
  77
  78   public void testNamedParametersInSecondMap2() throws Throwable {
  79     doVariantableTest();
  80   }
  81
  82   public void testNamedParametersExcludeExisted() throws Throwable {
  83     doVariantableTest("abx", "aby");
  84   }
  85
  86   public void testNamedParametersExcludeExisted2() throws Throwable {
  87     doVariantableTest("abx", "aby", "abz");
  88   }
  89
  90   public void testNamedParametersExcludeExistedMap() throws Throwable {
  91     doVariantableTest("abx", "aby");
  92   }
  93
  94   public void testNamedParametersForNotMap() throws Throwable {
  95     doBasicTest();
  96   }
  97
  98   public void testNamedParametersForConstructorCall() throws Throwable {
  99     doVariantableTest("hahaha", "hohoho");
 100   }
 101
 102   public void testUnfinishedMethodTypeParameter() throws Throwable {
 103     doVariantableTest("MyParameter", "MySecondParameter");
 104   }
 105
 106   public void testUnfinishedMethodTypeParameter2() throws Throwable {
 107     doVariantableTest("MyParameter", "MySecondParameter");
 108   }
 109
 110   public void testInstanceofHelpsDetermineType() throws Throwable {
 111     doBasicTest();
 112   }
 113
 114   public void testNotInstanceofDoesntHelpDetermineType() throws Throwable {
 115     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 116   }
 117
 118   public void testNotInstanceofDoesntHelpDetermineType2() throws Throwable {
 119     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 120   }
 121
 122   public void testTypeParameterCompletion() throws Throwable {
 123     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "put", "putAll");
 124   }
 125
 126   public void testCatchClauseParameter() throws Throwable {
 127     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "getCause", "getClass");
 128   }
 129
 130   public void testFieldSuggestedOnce1() throws Throwable {
 131     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 132     assertNull(myFixture.getLookupElements());
 133   }
 134
 135   public void testFieldSuggestedOnce2() throws Throwable {
 136     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 137     assertNull(myFixture.getLookupElements());
 138   }
 139
 140   public void testFieldSuggestedOnce3() throws Throwable {
 141     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 142     assertNull(myFixture.getLookupElements());
 143   }
 144
 145   public void testFieldSuggestedOnce4() throws Throwable {
 146     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 147     assertNull(myFixture.getLookupElements());
 148   }
 149
 150   public void testFieldSuggestedOnce5() throws Throwable {
 151     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + ".groovy");
 152     assertNull(myFixture.getLookupElements());
 153   }
 154
 155   public void testFieldSuggestedInMethodCall() throws Throwable {
 156     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + "_after.groovy");
 157   }
 158
 159   public void testMethodParameterNoSpace() throws Throwable {
 160     myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + "_after.groovy");
 161   }
 162
 163   public void testGroovyDocParameter() throws Throwable {
 164     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "xx", "xy");
 165   }
 166
 167   public void testInnerClassExtendsImplementsCompletion() throws Throwable {
 168     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "extends", "implements");
 169   }
 170
 171   public void testInnerClassCompletion() throws Throwable {
 172     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "Inner1", "Inner2");
 173   }
 174
 175   public void testQualifiedThisCompletion() throws Throwable {
 176     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "foo1", "foo2");
 177   }
 178
 179   public void testQualifiedSuperCompletion() throws Throwable {
 180     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "foo1", "foo2");
 181   }
 182
 183   public void testThisKeywordCompletionAfterClassName1() throws Throwable {
 184     doBasicTest();
 185   }
 186
 187   public void testThisKeywordCompletionAfterClassName2() throws Throwable {
 188     doBasicTest();
 189   }
 190
 191   public void testCompletionInParameterListInClosableBlock() throws Throwable { doBasicTest(); }
 192   public void testCompletionInParameterListInClosableBlock3() throws Throwable { doBasicTest(); }
 193
 194   public void testCompletionInParameterListInClosableBlock2() throws Throwable {
 195     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "aDouble");
 196   }
 197
 198   public void testStaticMemberFromInstanceContext() throws Throwable {
 199     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "var1", "var2");
 200   }
 201
 202   public void testInstanceMemberFromStaticContext() throws Throwable {
 203     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "var3", "var4");
 204   }
 205
 206   public void testTypeCompletionInVariableDeclaration1() throws Throwable {
 207     doBasicTest();
 208   }
 209
 210   public void testTypeCompletionInVariableDeclaration2() throws Throwable {
 211     doBasicTest();
 212   }
 213
 214   public void testTypeCompletionInParameter() throws Throwable {
 215     doBasicTest();
 216   }
 217
 218   public void testGStringConcatenationCompletion() throws Throwable {
 219     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "substring", "substring", "subSequence");
 220   }
 221
 222   public void testPropertyWithSecondUpperLetter() throws Exception {
 223     myFixture.testCompletionVariants(getTestName(false) + ".groovy", "geteMail", "getePost");
 224   }
 225
 226   public void testInferredVariableType() throws Exception {
 227     myFixture.configureByText "a.groovy", "def foo = 'xxx'; fo<caret>"
 228     def presentation = new LookupElementPresentation()
 229     myFixture.completeBasic()[0].renderElement(presentation)
 230     assert presentation.itemText == 'foo'
 231     assert presentation.typeText == 'String'
 232   }
 233
 234   public void testSubstitutedMethodType() throws Exception {
 235     myFixture.configureByText "a.groovy", "new HashMap<String, Integer>().put<caret>x"
 236     def presentation = new LookupElementPresentation()
 237     myFixture.completeBasic()[0].renderElement(presentation)
 238     assert presentation.itemText == 'put'
 239     assert presentation.tailText == '(String key, Integer value)'
 240     assert presentation.typeText == 'Integer'
 241   }
 242
 243   public void testIntCompletionInPlusMethod() {doBasicTest();}
 244   public void testIntCompletionInGenericParameter() {doBasicTest();}
 245
 246   public void testWhenSiblingIsStaticallyImported_Method() throws Exception {
 247     myFixture.addFileToProject "foo/Foo.groovy", """package foo
 248       class Foo {
 249         static def abcMethod() {}
 250         static def defMethod() {}
 251       }
 252     """
 253
 254     myFixture.configureByText("a.groovy", """
 255       import static foo.Foo.abcMethod
 256
 257       abcMethod()
 258       defM<caret>
 259     """)
 260     myFixture.completeBasic()
 261     myFixture.checkResult """
 262       import static foo.Foo.abcMethod
 263       import static foo.Foo.defMethod
 264
 265       abcMethod()
 266       defMethod()<caret>
 267     """
 268   }
 269
 270   public void testWhenSiblingIsStaticallyImported_Field() throws Exception {
 271     myFixture.addFileToProject "foo/Foo.groovy", """package foo
 272       class Foo {
 273         static def abcField = 4
 274         static def defField = 2
 275       }
 276     """
 277
 278     myFixture.configureByText("a.groovy", """
 279       import static foo.Foo.abcField
 280
 281       println abcField
 282       defF<caret>
 283     """)
 284     myFixture.completeBasic()
 285     myFixture.checkResult """
 286       import static foo.Foo.abcField
 287       import static foo.Foo.defField
 288
 289       println abcField
 290       defField<caret>
 291     """
 292   }
 293
 294   public void testCompletionNamedArgumentWithoutSpace() {
 295     def settings = CodeStyleSettingsManager.getSettings(getProject()).getCustomSettings(GroovyCodeStyleSettings.class)
 296     settings.SPACE_IN_NAMED_ARGUMENT = false
 297
 298     try {
 299       myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 300   class A {
 301    public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 302    { m(arg11<caret>) }
 303   }
 304   """)
 305       myFixture.completeBasic()
 306       myFixture.checkResult """
 307   class A {
 308    public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 309    { m(arg111:<caret>) }
 310   }
 311   """
 312     }
 313     finally {
 314       settings.SPACE_IN_NAMED_ARGUMENT = true
 315     }
 316   }
 317
 318   public void testCompletionNamedArgument1() {
 319     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 320 class A {
 321  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 322  { m(arg111: 1, arg<caret>: 2,   arg333: 3) }
 323 }
 324 """)
 325     myFixture.completeBasic()
 326
 327     myFixture.checkResult """
 328 class A {
 329  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 330  { m(arg111: 1, arg222: <caret>2,   arg333: 3) }
 331 }
 332 """
 333   }
 334
 335   public void testCompletionNamedArgument2() {
 336     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 337 class A {
 338  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 339  { m arg111: 1, arg<caret>: 2,   arg333: 3 }
 340 }
 341 """)
 342     myFixture.completeBasic()
 343
 344     myFixture.checkResult """
 345 class A {
 346  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 347  { m arg111: 1, arg222: <caret>2,   arg333: 3 }
 348 }
 349 """
 350   }
 351
 352   public void testCompletionNamedArgument3() {
 353     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 354 class A {
 355  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 356  { m arg1<caret> }
 357 }
 358 """)
 359     myFixture.completeBasic()
 360
 361     myFixture.checkResult """
 362 class A {
 363  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 364  { m arg111: <caret> }
 365 }
 366 """
 367   }
 368
 369   public void testCompletionNamedArgument4() {
 370     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 371 class A {
 372  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 373  { m (arg1<caret> zzz) }
 374 }
 375 """)
 376     myFixture.completeBasic()
 377
 378     myFixture.checkResult """
 379 class A {
 380  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 381  { m (arg111: <caret>, zzz) }
 382 }
 383 """
 384   }
 385
 386   public void testCompletionNamedArgument5() {
 387     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 388 class A {
 389  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 390  { m (arg1<caret>, {
 391       out << "asdasdas"
 392  } ) }
 393 }
 394 """)
 395     myFixture.completeBasic()
 396
 397     myFixture.checkResult("""
 398 class A {
 399  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 400  { m (arg111: <caret>, {
 401       out << "asdasdas"
 402  } ) }
 403 }
 404 """)
 405   }
 406
 407   public void testCompletionNamedArgument6() {
 408     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 409 class A {
 410  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 411  { m([arg1<caret>])}
 412 }
 413 """)
 414     myFixture.completeBasic()
 415
 416     myFixture.checkResult """
 417 class A {
 418  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 419  { m([arg111: <caret>])}
 420 }
 421 """
 422   }
 423
 424   public void testCompletionNamedArgument7() {
 425     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 426 class A {
 427  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 428  { m(arg1<caret>)}
 429 }
 430 """)
 431     myFixture.completeBasic()
 432
 433     myFixture.checkResult """
 434 class A {
 435  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 436  { m(arg111: <caret>)}
 437 }
 438 """
 439   }
 440
 441   public void testCompletionNamedArgument8() {
 442     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 443 class A {
 444  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 445  { m(arg1<caret>,)}
 446 }
 447 """)
 448     myFixture.completeBasic()
 449
 450     myFixture.checkResult """
 451 class A {
 452  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 453  { m(arg111: <caret>,)}
 454 }
 455 """
 456   }
 457
 458   public void testCompletionNamedArgumentWithDD() {
 459     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 460 class A {
 461  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 462  { m(arg<caret>)}
 463 }
 464 """)
 465     myFixture.completeBasic()
 466     myFixture.type(':')
 467
 468     myFixture.checkResult """
 469 class A {
 470  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 471  { m(arg111: <caret>)}
 472 }
 473 """
 474   }
 475
 476   public void testCompletionNamedArgumentReplace() {
 477     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 478 class A {
 479  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 480  { m(arg<caret>222: 'a')}
 481 }
 482 """)
 483     myFixture.completeBasic()
 484     myFixture.type("1\t")
 485
 486     myFixture.checkResult """
 487 class A {
 488  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 489  { m(arg111: 'a')}
 490 }
 491 """
 492   }
 493
 494   public void testCompletionNamedArgumentWithSpace() {
 495     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 496 class A {
 497  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 498  { m(arg<caret>)}
 499 }
 500 """)
 501     myFixture.completeBasic()
 502     myFixture.type(' ')
 503
 504     myFixture.checkResult """
 505 class A {
 506  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 507  { m(arg111: <caret>)}
 508 }
 509 """
 510   }
 511
 512   public void testCompletionNamedArgumentWithNewLine1() {
 513     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 514 class A {
 515  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 516  {
 517    m(arg<caret>
 518      arg222: 222,
 519    )
 520  }
 521 }
 522 """)
 523     myFixture.completeBasic()
 524     myFixture.type(' ')
 525
 526     myFixture.checkResult """
 527 class A {
 528  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 529  {
 530    m(arg111: <caret>,
 531      arg222: 222,
 532    )
 533  }
 534 }
 535 """
 536   }
 537
 538   public void testCompletionNamedArgumentWithNewLine2() {
 539     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 540 class A {
 541  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 542  {
 543    m(arg<caret>,
 544      arg222: 222,
 545    )
 546  }
 547 }
 548 """)
 549     myFixture.completeBasic()
 550     myFixture.type(':')
 551
 552     myFixture.checkResult """
 553 class A {
 554  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 555  {
 556    m(arg111: <caret>,
 557      arg222: 222,
 558    )
 559  }
 560 }
 561 """
 562   }
 563
 564   public void testCompletionNamedArgumentWithNewLine4() {
 565     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
 566 class A {
 567  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 568  {
 569    m(arg<caret>
 570      , arg222: 222,
 571      arg333: 333,
 572    )
 573  }
 574 }
 575 """)
 576     myFixture.completeBasic()
 577
 578     myFixture.checkResult """
 579 class A {
 580  public int m(arg) { return arg.arg111 + arg.arg222 + arg.arg333; }
 581  {
 582    m(arg111: <caret>
 583      , arg222: 222,
 584      arg333: 333,
 585    )
 586  }
 587 }
 588 """
 589   }
 590
 591   public void testSpreadOperator() {
 592     doVariantableTest("foo1", "foo2")
 593   }
 594
 595   public void testGrvy945() {
 596     def file = myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """class MyCategory {
 597   static def plus(MyCategory t, MyCat<caret>) {
 598   }
 599 }""")
 600     LookupElement[] lookupElements = myFixture.completeBasic()
 601     assertNull(lookupElements)
 602
 603     assertEquals """class MyCategory {
 604   static def plus(MyCategory t, MyCategory) {
 605   }
 606 }""", file.text
 607   }
 608
 609   void configure(String text) {
 610     myFixture.configureByText("a.groovy", text)
 611   }
 612
 613   public void testGenericsAfterNew() {
 614     configure "List<String> l = new ArrLi<caret>"
 615     myFixture.completeBasic()
 616     myFixture.type '\n'
 617     myFixture.checkResult "List<String> l = new ArrayList<String>(<caret>)"
 618   }
 619
 620   public void testAfterNewWithInner() {
 621     myFixture.addClass """class Zzoo {
 622         static class Impl {}
 623       }"""
 624     configure "Zzoo l = new Zz<caret>"
 625     myFixture.completeBasic()
 626     myFixture.checkResult "Zzoo l = new Zzoo()<caret>"
 627   }
 628
 629   public void testNothingAfterIntegerLiteral() {
 630     configure "2f<caret>"
 631     assertEmpty myFixture.completeBasic()
 632   }
 633
 634   public void testPackagedContainingClassNameAfterStatic() {
 635     myFixture.configureFromExistingVirtualFile(myFixture.addFileToProject("foo/cls.groovy", """
 636     package foo
 637     class Zzzzzzz {
 638       static Zzz<caret>
 639     }
 640     """).virtualFile)
 641     myFixture.completeBasic()
 642     assert myFixture.editor.document.text.contains("static Zzzzzzz")
 643   }
 644
 645   public void testDontCompleteSubpackageOfImplicitlyImported() {
 646     myFixture.addFileToProject "A.groovy", """
 647 in<caret>"""
 648     myFixture.testCompletionVariants "A.groovy", "int", "interface" //don't complete 'instrument' from 'java.lang'
 649   }
 650
 651
 652   public void testEatingThisReference() {
 653     configure "def x = []; x.<caret> this"
 654     myFixture.completeBasic()
 655     myFixture.type 'ad\t'
 656     myFixture.checkResult "def x = []; x.add(<caret>) this"
 657   }
 658
 659   public void testEatingClosingParenthesis() {
 660     checkCompletion """
 661 def xxxx = []
 662 def xxxy = []
 663 foo((xx<caret>):2)
 664 """, '\t', """
 665 def xxxx = []
 666 def xxxy = []
 667 foo((xxxx<caret>):2)
 668 """
 669   }
 670
 671   public void testDontAddStaticImportSecondTime() {
 672     configure """import static java.lang.String.format
 673 form<caret>"""
 674
 675     myFixture.completeBasic()
 676     myFixture.checkResult """import static java.lang.String.format
 677 format(<caret>)"""
 678   }
 679
 680   public void testImportAsterisk() {
 681     myFixture.configureByText "a.groovy", "import java.lang.<caret>"
 682     myFixture.completeBasic()
 683     myFixture.type '*\n'
 684     myFixture.checkResult "import java.lang.*<caret>"
 685   }
 686
 687   public void testNoDotsInImport() {
 688     myFixture.configureByText "a.groovy", "import java.<caret>"
 689     myFixture.completeBasic()
 690     myFixture.type 'lan\n'
 691     myFixture.checkResult "import java.lang<caret>"
 692   }
 693
 694   public void testInvalidScriptClass() {
 695     myFixture.addFileToProject("b.groovy", "//comment")
 696     myFixture.configureByText "a.groovy", "def b<caret>"
 697     myFixture.completeBasic()
 698     myFixture.checkResult "def b<caret>"
 699   }
 700
 701   public void testSpacesAroundEq() {
 702     myFixture.configureByText "a.groovy", "int xxx, xxy; xx<caret>"
 703     myFixture.completeBasic()
 704     myFixture.type '='
 705     myFixture.checkResult "int xxx, xxy; xxx = <caret>"
 706   }
 707
 708   public void testOnlyAnnotationsAfterAt() {
 709     myFixture.addClass "class AbcdClass {}; @interface AbcdAnno {}"
 710     myFixture.configureByText "a.groovy", "@Abcd<caret> class A {}"
 711     myFixture.completeBasic()
 712     myFixture.checkResult "@AbcdAnno<caret> class A {}"
 713   }
 714
 715   public void testOnlyAnnotationsAfterAtInMethodParameters() {
 716     myFixture.addClass "class AbcdClass {}; @interface AbcdAnno {}"
 717     myFixture.configureByText "a.groovy", "def foo(@Abcd<caret> ) {}"
 718     myFixture.completeBasic()
 719     myFixture.checkResult "def foo(@AbcdAnno<caret> ) {}"
 720   }
 721
 722   public void testNoCompletionInClassBodyComments() {
 723     myFixture.configureByText "a.groovy", "class Foo { /* protec<caret> */ }"
 724     assertEmpty(myFixture.completeBasic())
 725   }
 726
 727   public void testNoCompletionInCodeBlockComments() {
 728     myFixture.configureByText "a.groovy", "def Foo() { /* whil<caret> */ }"
 729     assertEmpty(myFixture.completeBasic())
 730   }
 731
 732   public void testParenthesesForExpectedClassTypeRegardlessInners() {
 733     myFixture.addClass "class Fooooo { interface Bar {} }"
 734     myFixture.configureByText "a.groovy", "Fooooo f = new Foo<caret>"
 735     myFixture.completeBasic()
 736     myFixture.checkResult "Fooooo f = new Fooooo()<caret>"
 737   }
 738
 739   public void testParenthesesForUnexpectedClassTypeRegardingInners() {
 740     myFixture.addClass "class Fooooo { interface Bar {} }"
 741     myFixture.configureByText "a.groovy", "Fooooo.Bar f = new Foo<caret>"
 742     myFixture.completeBasic()
 743     myFixture.checkResult "Fooooo.Bar f = new Fooooo<caret>"
 744   }
 745
 746   public void testOnlyExceptionsInCatch() {
 747     myFixture.addClass "package foo; public class AbcdClass {}; public class AbcdException extends Throwable {}"
 748     myFixture.configureByText "a.groovy", "try {} catch (Abcd<caret>"
 749     myFixture.completeBasic()
 750     myFixture.type('\n')
 751     myFixture.checkResult """import foo.AbcdException
 752
 753 try {} catch (AbcdException"""
 754   }
 755
 756   public void testOnlyExceptionsInCatch2() {
 757     myFixture.addClass "class AbcdClass {}; class AbcdException extends Throwable {}"
 758     myFixture.configureByText "a.groovy", "try {} catch (Abcd<caret> e) {}"
 759     myFixture.completeBasic()
 760     myFixture.checkResult "try {} catch (AbcdException<caret> e) {}"
 761   }
 762
 763   public void testTopLevelClassesFromPackaged() throws Throwable {
 764     myFixture.addClass "public class Fooooo {}"
 765     final text = "package foo; class Bar { Fooo<caret> }"
 766     def file = myFixture.addFileToProject("foo/Bar.groovy", text)
 767     myFixture.configureFromExistingVirtualFile file.virtualFile
 768     assertEmpty myFixture.completeBasic()
 769     myFixture.checkResult text
 770   }
 771
 772   public void testLocalVarOverlaysField() {
 773     myFixture.configureByText "a.groovy", """
 774 class A {
 775   def myVar = 2
 776
 777   def foo() {
 778     def myVar = 3
 779     print myVa<caret>
 780   }
 781 }"""
 782     myFixture.completeBasic()
 783
 784     myFixture.checkResult """
 785 class A {
 786   def myVar = 2
 787
 788   def foo() {
 789     def myVar = 3
 790     print myVar<caret>
 791   }
 792 }"""
 793
 794   }
 795
 796   public void testParenthesesInMethodCompletion() {
 797     myFixture.configureByText "a.groovy", """
 798 def foo(def a) {2}
 799 return fo<caret>"""
 800     myFixture.completeBasic()
 801     myFixture.checkResult """
 802 def foo(def a) {2}
 803 return foo()"""
 804   }
 805
 806   public void testFinishClassNameWithSquareBracket() {
 807     myFixture.addClass("class AbcdClass {}; class AbcdeClass {}")
 808     checkCompletion("Abcd<caret>", '[', "AbcdClass[<caret>]")
 809   }
 810
 811   public void testFinishClassNameWithSquareBracketAfterNew() {
 812     myFixture.addClass("class AbcdClass {}; class AbcdeClass {}")
 813     checkCompletion("new Abcd<caret>", '[', "new AbcdClass[<caret>]")
 814   }
 815
 816   public void testFinishMethodNameWithSquareBracket() {
 817     myFixture.addClass("""class AbcdClass {
 818       static int[] foo(int x){}
 819       static int[] fobar(){}
 820     }""")
 821     checkCompletion("AbcdClass.fo<caret>", '[', "AbcdClass.fobar()[<caret>]")
 822   }
 823
 824   public void testFinishVariableNameWithSquareBracket() {
 825     checkCompletion("int[] fooo, foobar; foo<caret>", '[', "int[] fooo, foobar; foobar[<caret>]")
 826   }
 827
 828   public void testFinishClassNameWithLt() {
 829     myFixture.addClass("class AbcdClass {}; class AbcdeClass {}")
 830     checkCompletion("Abcd<caret>", '<', "AbcdClass<<caret>>")
 831   }
 832
 833   public void testFinishClassNameWithLtAfterNew() {
 834     myFixture.addClass("class AbcdClass<T> {}; class AbcdeClass {}")
 835     checkCompletion("new Abcd<caret>", '<', "new AbcdClass<<caret>>()")
 836   }
 837
 838   public void testMapKeysUsedInFile() throws Exception {
 839     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
 840     doVariantableTest 'foo1', 'foo3', 'foo4', 'Foo5', 'Foo7'
 841   }
 842
 843   public void testNoClassesAsMapKeys() throws Exception {
 844     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
 845     doVariantableTest()
 846   }
 847
 848   public void testNamedArgsUsedInFile() throws Exception {
 849     myFixture.configureByFile(getTestName(false) + ".groovy");
 850     doVariantableTest 'false', 'foo2', 'float', 'foo1', 'foo3', 'foo4', 'foo5'
 851   }
 852
 853   public void testSuggestMembersOfExpectedType() {
 854     myFixture.addClass("enum Foo { aaaaaaaaaaaaaaaaaaaaaa, bbbbbb }")
 855     checkCompletion("Foo f = aaaaaaaa<caret>", '\n', "Foo f = Foo.aaaaaaaaaaaaaaaaaaaaaa<caret>")
 856   }
 857
 858   public void testFieldTypeAfterModifier() {
 859     myFixture.addClass("package bar; public class Fooooooooooo { }")
 860     checkCompletion '''
 861 class A {
 862   private Foooo<caret>
 863 }''', '\n', '''import bar.Fooooooooooo
 864
 865 class A {
 866   private Fooooooooooo<caret>
 867 }'''
 868   }
 869
 870   public void testSuperClassProperty() throws Exception {
 871     checkSingleItemCompletion """
 872 class A { def foooooooooooo }
 873
 874 class B extends A {
 875   def bar() {
 876     foooo<caret>
 877   }
 878 }
 879 """, """
 880 class A { def foooooooooooo }
 881
 882 class B extends A {
 883   def bar() {
 884     foooooooooooo<caret>
 885   }
 886 }
 887 """
 888   }
 889
 890   public void testDoubleSpace() {
 891     checkCompletion "asse<caret>x", ' ', 'assert <caret>x'
 892   }
 893
 894   public void testDontShowAccessors() {
 895     assertNull doContainsTest("getFoo", """
 896 class MyClass {
 897   def foo
 898 }
 899
 900 def a = new MyClass()
 901 a.<caret>""")
 902   }
 903
 904   public void testPreferInstanceof() {
 905     caseSensitiveNone()
 906
 907     configure '''
 908 class Fopppp {
 909     def foo() {
 910         assert x ins<caret>
 911     }
 912 }
 913 class Instantiation {}
 914 '''
 915     myFixture.completeBasic()
 916     assert myFixture.lookupElementStrings[0] == 'instanceof'
 917   }
 918
 919   public void testForFinal() {
 920     assert doContainsTest('final', '''
 921 class Fopppp {
 922     def foo() {
 923         for(fin<caret>
 924     }
 925 }
 926 ''')
 927   }
 928
 929   public void testExcludeStringBuffer() {
 930     assert doContainsTest('StringBuffer', 'StringBuff<caret>f')
 931     CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = [StringBuffer.name] as String[]
 932     try {
 933       assert !doContainsTest('StringBuffer', 'StringBuff<caret>f')
 934     }
 935     finally {
 936       CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = new String[0]
 937     }
 938   }
 939
 940   private doContainsTest(String itemToCheck, String text) {
 941     myFixture.configureByText "a.groovy", text
 942
 943     final LookupElement[] completion = myFixture.completeBasic()
 944     return completion.find {println it.lookupString;itemToCheck == it.lookupString}
 945   }
 946
 947   public void testWordCompletionInLiterals() {
 948     checkSingleItemCompletion('def foo = "fo<caret>"', 'def foo = "foo<caret>"')
 949   }
 950   public void testWordCompletionInLiterals2() {
 951     checkSingleItemCompletion('''
 952 println "abcd"
 953 "a<caret>"
 954 ''', '''
 955 println "abcd"
 956 "abcd<caret>"
 957 ''')
 958   }
 959
 960   public void testWordCompletionInComments() {
 961     checkSingleItemCompletion('''
 962 println "abcd"
 963 // a<caret>"
 964 ''', '''
 965 println "abcd"
 966 // abcd<caret>"
 967 ''')
 968   }
 969
 970   public void testNoModifiersAfterDef() throws Exception {
 971     checkSingleItemCompletion 'def priv<caret>', 'def priv<caret>'
 972   }
 973
 974   public void testIfSpace() { checkCompletion 'int iff; if<caret>', ' ', "int iff; if <caret>" }
 975
 976   public void testIfParenthesis() { checkCompletion 'int iff; if<caret>', '(', "int iff; if (<caret>)" }
 977
 978   public void testEnumPropertyType() {
 979     checkSingleItemCompletion 'enum Foo {a,b; static List<StringBui<caret>>', "enum Foo {a,b; static List<StringBuilder<caret>>"
 980   }
 981
 982   public void testEnumPropertyType2() {
 983     checkSingleItemCompletion 'enum Foo {a,b; static List<StringBui<caret>', "enum Foo {a,b; static List<StringBuilder<caret>"
 984   }
 985
 986   public void testShowAccessor() {
 987     assertNotNull doContainsTest("getFoo", """
 988 class MyClass {
 989   def foo
 990 }
 991
 992 def a = new MyClass()
 993 a.g<caret>
 994 """)
 995   }
 996
 997   public void testContinue() {
 998     assertNotNull doContainsTest("continue", """
 999 def conti = 4
1000 while(true) {
1001   if (tst) cont<caret>
1002 }""")
1003
1004   }
1005
1006   public void testPreferParametersToClasses() {
1007     caseSensitiveNone()
1008
1009     myFixture.configureByText "a.groovy", "def foo(stryng) { println str<caret> }"
1010     myFixture.completeBasic()
1011     assert myFixture.lookupElementStrings[0] == 'stryng'
1012   }
1013
1014   private def caseSensitiveNone() {
1015     CodeInsightSettings.instance.COMPLETION_CASE_SENSITIVE = CodeInsightSettings.NONE
1016   }
1017
1018   public void testFieldVsPackage() {
1019     myFixture.addFileToProject 'aaa/bbb/Foo.groovy', 'package aaa.bbb; class Foo{}'
1020     def file = myFixture.addFileToProject('aaa/bar.groovy', '''
1021 package aaa
1022
1023 import aaa.*
1024
1025 class X {
1026   def bbb = 'text'
1027
1028   def foo() {
1029     bbb.<caret>toString()
1030   }
1031 }
1032 ''')
1033     myFixture.configureFromExistingVirtualFile file.virtualFile
1034     myFixture.completeBasic()
1035     assertFalse(myFixture.lookupElementStrings.contains('Foo'))
1036   }
1037
1038   public void testFieldVsPackage2() {
1039     myFixture.addFileToProject 'aaa/bbb/Foo.groovy', 'package aaa.bbb; class Foo{}'
1040     def file = myFixture.addFileToProject('aaa/bar.groovy', '''
1041 package aaa
1042
1043 import aaa.*
1044
1045 class X {
1046   def bbb = 'text'
1047
1048   def foo() {
1049     bbb.<caret>
1050   }
1051 }
1052 ''')
1053     myFixture.configureFromExistingVirtualFile file.virtualFile
1054     myFixture.completeBasic()
1055     assertFalse(myFixture.lookupElementStrings.contains('Foo'))
1056   }
1057
1058   public void testClassNameBeforeParentheses(){
1059     doBasicTest()
1060   }
1061
1062   public void testNewClassGenerics() {
1063     checkSingleItemCompletion 'new ArrayLi<caret>', 'new ArrayList<<caret>>()'
1064   }
1065
1066   public void testInnerClassStart() {
1067     checkSingleItemCompletion 'class Foo { cl<caret> }', 'class Foo { class <caret> }'
1068   }
1069
1070   public void testPropertyBeforeAccessor() {
1071     doVariantableTest 'soSe', 'setSoSe'
1072   }
1073
1074   public void testSortOrder0() {
1075     doVariantableTest 'se', 'setMetaClass', 'setProperty', 'setSe'
1076   }
1077
1078   public void testPrimitiveCastOverwrite() {
1079     checkCompletion 'byte v1 = (by<caret>te) 0', '\t', 'byte v1 = (byte<caret>) 0'
1080   }
1081
1082   public void testInitializerMatters() throws Exception {
1083     myFixture.configureByText("a.groovy", "class Foo {{ String f<caret>x = getFoo(); }; String getFoo() {}; }");
1084     myFixture.completeBasic()
1085     assert myFixture.lookupElementStrings == ["foo"]
1086   }
1087
1088   public void testFieldInitializerMatters() throws Exception {
1089     myFixture.configureByText("a.groovy", "class Foo { String f<caret>x = getFoo(); String getFoo() {}; }");
1090     myFixture.completeBasic()
1091     assert myFixture.lookupElementStrings == ["foo"]
1092   }
1093
1094   public void testAccessStaticViaInstanceSecond() throws Exception {
1095     myFixture.configureByText("a.groovy", """
1096 public class KeyVO {
1097   { this.fo<caret>x }
1098   static void foo() {}
1099 }
1100 """);
1101     myFixture.complete(CompletionType.BASIC, 1)
1102     assert !myFixture.lookupElementStrings
1103     myFixture.complete(CompletionType.BASIC, 2)
1104     assert myFixture.lookupElementStrings == ["foo"]
1105   }
1106
1107   public void testNoRepeatingModifiers() {
1108     myFixture.configureByText 'a.groovy', 'class A { public static <caret> }'
1109     myFixture.completeBasic()
1110     assert !('public' in myFixture.lookupElementStrings)
1111     assert !('static' in myFixture.lookupElementStrings)
1112     assert 'final' in myFixture.lookupElementStrings
1113   }
1114
1115   public void testSpaceTail() {
1116     checkCompletion 'class A <caret> ArrayList {}', ' ', 'class A extends <caret> ArrayList {}'
1117     checkCompletion 'class A <caret> ArrayList {}', '\n', 'class A extends<caret> ArrayList {}'
1118     checkSingleItemCompletion 'class Foo impl<caret> {}', 'class Foo implements <caret> {}'
1119   }
1120
1121   public void testPreferInterfacesInImplements() {
1122     myFixture.addClass('interface FooIntf {}')
1123     myFixture.addClass('class FooClass {}')
1124     doVariantableTest('FooIntf', 'FooClass')
1125   }
1126 }