/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/GppFunctionalTest.groovy

https://bitbucket.org/nbargnesi/idea · Groovy · 616 lines · 539 code · 74 blank · 3 comment · 2 complexity · a735a8bcfe77180df1928d3540b35ce6 MD5 · raw file 

    

  1. package org.jetbrains.plugins.groovy.lang

    2. 

  2. 

    3. 

  3. import com.intellij.codeInsight.generation.OverrideImplementUtil

    4. 

  4. import com.intellij.codeInsight.lookup.LookupManager

    5. 

  5. import com.intellij.codeInsight.navigation.GotoImplementationHandler

    6. 

  6. import com.intellij.codeInspection.deadCode.UnusedDeclarationInspection

    7. 

  7. import com.intellij.openapi.module.Module

    8. 

  8. import com.intellij.openapi.roots.ContentEntry

    9. 

  9. import com.intellij.openapi.roots.ModifiableRootModel

    10. 

  10. import com.intellij.openapi.roots.OrderRootType

    11. 

  11. import com.intellij.openapi.roots.libraries.Library

    12. 

  12. import com.intellij.openapi.vfs.JarFileSystem

    13. 

  13. import com.intellij.psi.search.GlobalSearchScope

    14. 

  14. import com.intellij.testFramework.LightProjectDescriptor

    15. 

  15. import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor

    16. 

  16. import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase

    17. 

  17. import junit.framework.ComparisonFailure

    18. 

  18. import org.jetbrains.annotations.NotNull

    19. 

  19. import org.jetbrains.plugins.groovy.codeInspection.GroovyUnusedDeclarationInspection

    20. 

  20. import org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignabilityCheckInspection

    21. 

  21. import org.jetbrains.plugins.groovy.codeInspection.unassignedVariable.UnassignedVariableAccessInspection

    22. 

  22. import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition

    23. 

  23. import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod

    24. 

  24. import org.jetbrains.plugins.groovy.util.TestUtils

    25. 

  25. import com.intellij.psi.*

    26. 

  26. 

    27. 

  27. /**

    28. 

  28.  * @author peter

    29. 

  29.  */

    30. 

  30. class GppFunctionalTest extends LightCodeInsightFixtureTestCase {

    31. 

  31. 

    32. 

  32.   @NotNull

    33. 

  33.   @Override

    34. 

  34.   protected LightProjectDescriptor getProjectDescriptor() {

    35. 

  35.     return GppProjectDescriptor.instance;

    36. 

  36.   }

    37. 

  37. 

    38. 

  38.   protected void setUp() {

    39. 

  39.     super.setUp()

    40. 

  40.   }

    41. 

  41. 

    42. 

  42.   public void testCastListToIterable() throws Exception {

    43. 

  43.     myFixture.addClass("class X extends java.util.ArrayList<Integer> {}")

    44. 

  44.     testAssignability """

    45. 

  45. X ints = [239, 4.2d]

    46. 

  46. """

    47. 

  47.   }

    48. 

  48. 

    49. 

  49.   public void testCastListToAnything() throws Exception {

    50. 

  50.     testAssignability """

    51. 

  51. File f1 = ['path']

    52. 

  52. File f2 = <warning descr="Constructor 'File' in 'java.io.File' cannot be applied to '(java.lang.String, java.lang.Integer, java.lang.Boolean, java.lang.Integer)'">['path', 2, true, 42]</warning>

    53. 

  53. """

    54. 

  54.   }

    55. 

  55. 

    56. 

  56.   public void testCastMapToAnotherMap() throws Exception {

    57. 

  57.     myFixture.addClass """

    58. 

  58. public class Y extends java.util.HashMap<String, String> {

    59. 

  59.   public Y(int initialCapacity) {

    60. 

  60.     super(initialCapacity);

    61. 

  61.   }

    62. 

  62. }

    63. 

  63. """

    64. 

  64. 

    65. 

  65.     testAssignability """

    66. 

  66. HashMap<String, File> m1 = ['a':['b']]

    67. 

  67. Y y = <warning descr="Constructor 'Y' in 'Y' cannot be applied to '(['a':java.lang.String])'">[a:'b']</warning>

    68. 

  68. """

    69. 

  69.   }

    70. 

  70. 

    71. 

  71.   public void testAnonymousClass() throws Exception {

    72. 

  72.     myFixture.enableInspections new GroovyAssignabilityCheckInspection()

    73. 

  73.     testAssignability """

    74. 

  74. def x = new Object() {

    75. 

  75.   def foo() {

    76. 

  76.     HashMap<String, File> m1 = ['a':['b']]

    77. 

  77.     HashMap<String, File> m2 = <warning descr="Cannot assign 'File' to 'HashMap<String, File>'">new File('aaa')</warning>

    78. 

  78.   }

    79. 

  79. }

    80. 

  80. """

    81. 

  81.   }

    82. 

  82. 

    83. 

  83.   public void testCastMapToObject() throws Exception {

    84. 

  84.     myFixture.addClass("class Foo { String name; void foo() {} }")

    85. 

  85.     testAssignability """

    86. 

  86. Foo f = [name: 'aaa', foo: { println 'hi' }, anotherProperty: 42 ]

    87. 

  87. """

    88. 

  88.   }

    89. 

  89. 

    90. 

  90.   void testAssignability(String text) {

    91. 

  91.     myFixture.enableInspections new GroovyAssignabilityCheckInspection()

    92. 

  92.     PsiFile file = configureGppScript(text)

    93. 

  93.     myFixture.testHighlighting(true, false, false, file.virtualFile)

    94. 

  94.   }

    95. 

  95. 

    96. 

  96.   private PsiFile configureScript(String text) {

    97. 

  97.     return myFixture.configureByText("a.groovy", text)

    98. 

  98.   }

    99. 

  99.   private PsiFile configureGppScript(String text) {

    100. 

  100.     return myFixture.configureByText("a.gpp", text)

    101. 

  101.   }

    102. 

  102. 

    103. 

  103.   public void testDeclaredVariableTypeIsMoreImportantThanTheInitializerOne() throws Exception {

    104. 

  104.     configureScript("""

    105. 

  105. File f = ['path']

    106. 

  106. f.mk<caret>

    107. 

  107. """)

    108. 

  108.     myFixture.completeBasic()

    109. 

  109.     assertSameElements myFixture.lookupElementStrings, "mkdir", "mkdirs"

    110. 

  110.   }

    111. 

  111.   

    112. 

  112.   public void testDeclaredVariableTypeIsMoreImportantThanTheInitializerOne2() throws Exception {

    113. 

  113.     myFixture.addClass """

    114. 

  114. public class Some {

    115. 

  115.     public int prop

    116. 

  116. 

    117. 

  117.     public void f_foo() {}

    118. 

  118.     public void f_bar() {}

    119. 

  119. }

    120. 

  120. """

    121. 

  121. 

    122. 

  122.     configureScript("""

    123. 

  123. Some s = [prop: 239]

    124. 

  124. s.f_<caret>

    125. 

  125. """)

    126. 

  126.     myFixture.completeBasic()

    127. 

  127.     assertSameElements myFixture.lookupElementStrings, "f_foo", "f_bar"

    128. 

  128.   }

    129. 

  129. 

    130. 

  130.   public void testResolveMethod() throws Exception {

    131. 

  131.     myFixture.configureByText("a.groovy", """

    132. 

  132. def foo(File f) {}

    133. 

  133. @Typed def bar() {

    134. 

  134.   fo<caret>o(['path'])

    135. 

  135. }

    136. 

  136. """)

    137. 

  137.     def reference = findReference()

    138. 

  138.     def target = reference.resolve()

    139. 

  139.     assertEquals "foo", ((GrMethod)target).name

    140. 

  140.   }

    141. 

  141. 

    142. 

  142.   private PsiReference findReference() {

    143. 

  143.     return myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)

    144. 

  144.   }

    145. 

  145. 

    146. 

  146.   public void testOverloadingWithConversion() throws Exception {

    147. 

  147.     myFixture.configureByText("a.groovy", """

    148. 

  148. def foo(List l) {}

    149. 

  149. def foo(File f) {}

    150. 

  150. @Typed def bar() {

    151. 

  151.   fo<caret>o(['path'])

    152. 

  152. }

    153. 

  153. """)

    154. 

  154.     def reference = findReference()

    155. 

  155.     def target = reference.resolve()

    156. 

  156.     assertNotNull target

    157. 

  157.     assert target.text.contains("List l")

    158. 

  158.   }

    159. 

  159. 

    160. 

  160.   public void testWrongProperty() throws Exception {

    161. 

  161. myFixture.configureByText 'a.gpp', '''

    162. 

  162. class ClassA {

    163. 

  163.   def prop = 2

    164. 

  164.   def bar() {

    165. 

  165.     def t = new Object()

    166. 

  166.     t.pr<caret>op

    167. 

  167.   }

    168. 

  168. }'''

    169. 

  169.     assert !findReference().resolve()

    170. 

  170.   }

    171. 

  171. 

    172. 

  172.   public void testCastClosureToOneMethodClass() throws Exception {

    173. 

  173.     myFixture.addClass """

    174. 

  174. public abstract class Foo {

    175. 

  175.   public abstract void foo(String s);

    176. 

  176.   public abstract void bar(String s);

    177. 

  177. }

    178. 

  178. public interface Action {

    179. 

  179.   void act();

    180. 

  180. }

    181. 

  181. """

    182. 

  182. 

    183. 

  183.     testAssignability """

    184. 

  184. Foo f = <warning descr="Cannot assign 'Closure' to 'Foo'">{ println it }</warning>

    185. 

  185. Function1<String, Object> f1 = { println it }

    186. 

  186. Function1<String, Object> f2 = { x=42 -> println x }

    187. 

  187. Function1<String, Object> f3 = <warning descr="Cannot assign 'Closure' to 'Function1<String, Object>'">{ int x -> println x }</warning>

    188. 

  188. Runnable r = { println it }

    189. 

  189. Action a = { println it }

    190. 

  190. Action a1 = { a2 = 2 -> println a2 }

    191. 

  191. """

    192. 

  192.   }

    193. 

  193. 

    194. 

  194.   public void testClosureParameterTypesInAssignment() throws Exception {

    195. 

  195.     configureScript "Function1<String, Object> f = { it.subs<caret> }"

    196. 

  196.     myFixture.completeBasic()

    197. 

  197.     assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"

    198. 

  198.   }

    199. 

  199. 

    200. 

  200.   public void testClosureParameterTypesInMethodInvocation() throws Exception {

    201. 

  201.     myFixture.configureByText "a.groovy", """

    202. 

  202. def foo(int a = 1, Function1<String, Object> f) {}

    203. 

  203. def foo(String s) {}

    204. 

  204. def foo(Function2<Integer, String, Object> f) {}

    205. 

  205. 

    206. 

  206. @Typed def bar() {

    207. 

  207.   foo { it.subsREF }

    208. 

  208.   foo(1, { it.subsREF })

    209. 

  209.   foo 1, { it.subsREF }

    210. 

  210.   foo(1) { it.subsREF }

    211. 

  211.   foo { a -> a.subsREF }

    212. 

  212.   foo { a, int b=2 -> a.subsREF }

    213. 

  213.   foo { a, b -> b.subsREF }

    214. 

  214. }

    215. 

  215. """

    216. 

  216.     def text = myFixture.file.text

    217. 

  217.     def pos = 0

    218. 

  218.     while (true) {

    219. 

  219.       pos = text.indexOf("REF", pos+1)

    220. 

  220.       if (pos < 0) {

    221. 

  221.         break

    222. 

  222.       }

    223. 

  223.       myFixture.editor.caretModel.moveToOffset pos

    224. 

  224.       myFixture.completeBasic()

    225. 

  225.       try {

    226. 

  226.         assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"

    227. 

  227.       }

    228. 

  228.       catch (ComparisonFailure ex) {

    229. 

  229.         println "at: " + text[0..<pos] + "<caret>" + text[pos..<text.size()]

    230. 

  230.         throw ex

    231. 

  231.       }

    232. 

  232.       LookupManager.getInstance(project).hideActiveLookup()

    233. 

  233.     }

    234. 

  234.   }

    235. 

  235. 

    236. 

  236.   public void testReturnTypeOneMethodInterface() throws Exception {

    237. 

  237.     myFixture.configureByText "a.groovy", """

    238. 

  238. @Typed Function1<String, Integer> bar() {

    239. 

  239.    { it.subs<caret> }

    240. 

  240. }

    241. 

  241. """

    242. 

  242.     myFixture.completeBasic()

    243. 

  243.     assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"

    244. 

  244.   }

    245. 

  245. 

    246. 

  246.   public void testClosureInMapInstantiation() throws Exception {

    247. 

  247.     myFixture.configureByText "a.groovy", """

    248. 

  248. class Foo<T> {

    249. 

  249.   int foo(T a) {}

    250. 

  250. }

    251. 

  251. 

    252. 

  252. @Typed Foo<String> bar() {

    253. 

  253.     return [foo: { it.subs<caret> }]

    254. 

  254. }

    255. 

  255. """

    256. 

  256.     myFixture.completeBasic()

    257. 

  257.     assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"

    258. 

  258.   }

    259. 

  259. 

    260. 

  260.   public void testClosureInMapInstantiationBoxPrimitives() throws Exception {

    261. 

  261.     myFixture.configureByText "a.groovy", """

    262. 

  262. class Foo {

    263. 

  263.   int foo(int a) {}

    264. 

  264. }

    265. 

  265. 

    266. 

  266. @Typed Foo bar() {

    267. 

  267.     return [foo: { it.intV<caret>V }]

    268. 

  268. }

    269. 

  269. """

    270. 

  270.     myFixture.completeBasic()

    271. 

  271.     assertSameElements myFixture.lookupElementStrings, "intValue"

    272. 

  272.   }

    273. 

  273. 

    274. 

  274.   public void testClosureInListInstantiation() throws Exception {

    275. 

  275.     myFixture.configureByText "a.groovy", """

    276. 

  276. class Foo {

    277. 

  277.   def Foo(int a, Function1<String, Integer> f) {}

    278. 

  278. }

    279. 

  279. 

    280. 

  280. @Typed Foo foo() {

    281. 

  281.   [239, { s -> s.subs<caret> }]

    282. 

  282. }

    283. 

  283. """

    284. 

  284.     myFixture.completeBasic()

    285. 

  285.     assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"

    286. 

  286.   }

    287. 

  287. 

    288. 

  288.   public void testTraitHighlighting() throws Exception {

    289. 

  289.     myFixture.configureByText "a.groovy", """

    290. 

  290. @Trait

    291. 

  291. abstract class Intf {

    292. 

  292.   abstract void foo()

    293. 

  293.   void bar() {}

    294. 

  294. }

    295. 

  295. <error descr="Method 'foo' is not implemented">class Foo implements Intf</error> {}

    296. 

  296. <error descr="Method 'foo' is not implemented">class Wrong extends Foo</error> {}

    297. 

  297. class Bar implements Intf {

    298. 

  298.   void foo() {}

    299. 

  299. }

    300. 

  300. """

    301. 

  301.     myFixture.testHighlighting(true, false, false, myFixture.file.virtualFile)

    302. 

  302.   }

    303. 

  303. 

    304. 

  304.   public void testTraitImplementingAndNavigation() throws Exception {

    305. 

  305.     myFixture.configureByText "a.groovy", """

    306. 

  306. @Trait

    307. 

  307. abstract class <caret>Intf {

    308. 

  308.   abstract void foo()

    309. 

  309.   void bar() {}

    310. 

  310. }

    311. 

  311. class Foo implements Intf {}

    312. 

  312. class Bar implements Intf {

    313. 

  313.   void foo() {}

    314. 

  314. }

    315. 

  315. class BarImpl extends Bar {}

    316. 

  316. """

    317. 

  317.     def facade = JavaPsiFacade.getInstance(getProject())

    318. 

  318.     def allScope = GlobalSearchScope.allScope(project)

    319. 

  319.     assertOneElement(OverrideImplementUtil.getMethodsToOverrideImplement(facade.findClass("Foo", allScope), true))

    320. 

  320. 

    321. 

  321.     GrTypeDefinition barClass = facade.findClass("Bar", allScope) as GrTypeDefinition

    322. 

  322.     assertEmpty(OverrideImplementUtil.getMethodsToOverrideImplement(barClass, true))

    323. 

  323.     assertTrue "bar" in OverrideImplementUtil.getMethodsToOverrideImplement(barClass, false).collect { ((PsiMethod) it.element).name }

    324. 

  324. 

    325. 

  325.     assertEmpty(OverrideImplementUtil.getMethodsToOverrideImplement(facade.findClass("BarImpl", allScope), true))

    326. 

  326. 

    327. 

  327.     def implementations = new GotoImplementationHandler().getSourceAndTargetElements(myFixture.editor, myFixture.file).targets

    328. 

  328.     assertEquals Arrays.toString(implementations), 3, implementations.size()

    329. 

  329.   }

    330. 

  330. 

    331. 

  331.   public void testResolveToStdLib() throws Exception {

    332. 

  332.     configureScript """

    333. 

  333. @Typed def foo(List<String> l) {

    334. 

  334.   l.ea<caret>ch { it.substring(1) }

    335. 

  335. }

    336. 

  336. """

    337. 

  337.     PsiMethod method = resolveReference().navigationElement as PsiMethod

    338. 

  338.     assertEquals "each", method.name

    339. 

  339.     assertEquals "groovypp.util.Iterations", method.containingClass.qualifiedName

    340. 

  340.   }

    341. 

  341. 

    342. 

  342.   public void testResolveToStdLibWithArrayQualifier() throws Exception {

    343. 

  343.     configureGppScript """

    344. 

  344. Integer[] a = []

    345. 

  345. a.fol<caret>dLeft(2, { a, b -> a+b })

    346. 

  346. """

    347. 

  347.     PsiMethod method = resolveReference().navigationElement as PsiMethod

    348. 

  348.     assertEquals "foldLeft", method.name

    349. 

  349.     assertEquals "groovypp.util.Iterations", method.containingClass.qualifiedName

    350. 

  350.   }

    351. 

  351. 

    352. 

  352.   private PsiElement resolveReference() {

    353. 

  353.     return findReference().resolve()

    354. 

  354.   }

    355. 

  355. 

    356. 

  356.   public void testResolveToSuperMethodClosureSyntax() {

    357. 

  357.     configureScript """

    358. 

  358. abstract class Super implements Runnable {

    359. 

  359.   def method(int bar) {}

    360. 

  360. }

    361. 

  361. 

    362. 

  362. Super s = { <caret>method(2) } as Super

    363. 

  363. """

    364. 

  364.     assert resolveReference() instanceof GrMethod

    365. 

  365.   }

    366. 

  366. 

    367. 

  367.   public void testMethodTypeParameterInference() throws Exception {

    368. 

  368.     configureScript """

    369. 

  369. @Typed package aaa

    370. 

  370. 

    371. 

  371. java.util.concurrent.atomic.AtomicReference<Integer> r = [2]

    372. 

  372. r.apply { it.intV<caret>i }

    373. 

  373. """

    374. 

  374.     myFixture.completeBasic()

    375. 

  375.     assertSameElements myFixture.getLookupElementStrings(), "intValue"

    376. 

  376.   }

    377. 

  377. 

    378. 

  378.   public void testMethodTypeParameterInference2() throws Exception {

    379. 

  379.     configureScript """

    380. 

  380. @Typed package aaa

    381. 

  381. 

    382. 

  382. java.util.concurrent.atomic.AtomicReference<Integer> r = [2]

    383. 

  383. r.apply { it.intV<caret>i } {}

    384. 

  384. """

    385. 

  385.     myFixture.completeBasic()

    386. 

  386.     assertSameElements myFixture.getLookupElementStrings(), "intValue"

    387. 

  387.   }

    388. 

  388. 

    389. 

  389.   public void testGotoSuperMethodFromMapLiterals() throws Exception {

    390. 

  390.     PsiClass point = myFixture.addClass("""

    391. 

  391. class Point {

    392. 

  392.   Point() {}

    393. 

  393.   Point(int y) {}

    394. 

  394.   int y;

    395. 

  395.   void setX(int x) {}

    396. 

  396.   void move(int x, int y) {}

    397. 

  397.   void move(int y) {}

    398. 

  398. }""")

    399. 

  399. 

    400. 

  400.     configureScript "Point p = [<caret>y:2]"

    401. 

  401.     assertEquals point.findFieldByName("y", false), resolveReference()

    402. 

  402. 

    403. 

  403.     configureScript "Point p = [<caret>x:2]"

    404. 

  404.     assertEquals point.findMethodsByName("setX", false)[0], resolveReference()

    405. 

  405. 

    406. 

  406.     configureScript "Point p = [mo<caret>ve: { x, y -> z }]"

    407. 

  407.     assertEquals point.findMethodsByName("move", false)[0], resolveReference()

    408. 

  408. 

    409. 

  409.     configureScript "Point p = [mo<caret>ve: ]"

    410. 

  410.     def resolveResults = multiResolveReference()

    411. 

  411.     assertSameElements resolveResults.collect { it.element }, point.findMethodsByName("move", false)

    412. 

  412.   }

    413. 

  413. 

    414. 

  414.   ResolveResult[] multiResolveReference() {

    415. 

  415.     return ((PsiPolyVariantReference) myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)).multiResolve(true)

    416. 

  416.   }

    417. 

  417. 

    418. 

  418.   public void testGotoSuperConstructorFromMapLiterals() throws Exception {

    419. 

  419.     PsiClass point = myFixture.addClass("""

    420. 

  420. class Point {

    421. 

  421.   Point() {}

    422. 

  422.   Point(int y) {}

    423. 

  423. }""")

    424. 

  424. 

    425. 

  425.     configureGppScript "Point p = [su<caret>per: 2]"

    426. 

  426.     assertEquals point.constructors[1], resolveReference()

    427. 

  427. 

    428. 

  428.     configureGppScript "Point p = [su<caret>per: [2]]"

    429. 

  429.     assertEquals point.constructors[1], resolveReference()

    430. 

  430. 

    431. 

  431.     configureGppScript "Point p = ['su<caret>per': []]"

    432. 

  432.     assertEquals point.constructors[0], resolveReference()

    433. 

  433. 

    434. 

  434.     configureGppScript "Point p = ['su<caret>per': 'a']"

    435. 

  435.     assertEquals 1, multiResolveReference().size()

    436. 

  436.   }

    437. 

  437. 

    438. 

  438.   public void testGotoSuperConstructorFromLiteralOnsets() throws Exception {

    439. 

  439.     PsiClass point = myFixture.addClass("""

    440. 

  440. class Point {

    441. 

  441.   Point() {}

    442. 

  442.   Point(int y) {}

    443. 

  443. }""")

    444. 

  444. 

    445. 

  445.     configureGppScript "Point p = <caret>[super: 2]"

    446. 

  446.     assertEquals point.constructors[1], resolveReference()

    447. 

  447. 

    448. 

  448.     configureGppScript "Point p = <caret>[2]"

    449. 

  449.     assertEquals point.constructors[1], resolveReference()

    450. 

  450. 

    451. 

  451.     configureGppScript "Point p = <caret>[]"

    452. 

  452.     assertEquals point.constructors[0], resolveReference()

    453. 

  453. 

    454. 

  454.     configureGppScript "Point p = <caret>[:]"

    455. 

  455.     assertEquals point.constructors[0], resolveReference()

    456. 

  456. 

    457. 

  457.     configureGppScript "Point p = <caret>[239, 42]"

    458. 

  458.     assertEquals 2, multiResolveReference().size()

    459. 

  459. 

    460. 

  460.     configureGppScript """

    461. 

  461. def foo(Point p) {}

    462. 

  462. foo(<caret>[2, 3])

    463. 

  463. """

    464. 

  464.     assertEquals 2, multiResolveReference().size()

    465. 

  465. 

    466. 

  466.     configureGppScript """

    467. 

  467. def foo(Point... p) {}

    468. 

  468. foo(<caret>['super':[2, 3]])

    469. 

  469. """

    470. 

  470.     assertEquals 2, multiResolveReference().size()

    471. 

  471.   }

    472. 

  472. 

    473. 

  473.   public void testGotoClassFromLiteralOnsetsWhenNoConstructorsPresent() throws Exception {

    474. 

  474.     PsiClass point = myFixture.addClass(""" class Point { }""")

    475. 

  475.     configureGppScript "Point p = <caret>[super: 2]"

    476. 

  476.     assertEquals point, resolveReference()

    477. 

  477. 

    478. 

  478.     configureGppScript "Point p = <caret>[]"

    479. 

  479.     assertEquals point, resolveReference()

    480. 

  480.   }

    481. 

  481. 

    482. 

  482.   public void testNoGotoObjectFromLiteral() throws Exception {

    483. 

  483.     myFixture.addClass(""" class Point { }""")

    484. 

  484. 

    485. 

  485.     configureGppScript "def p = <caret>[]"

    486. 

  486.     assertNull findReference()

    487. 

  487.   }

    488. 

  488. 

    489. 

  489.   public void testHighlightInapplicableLiteralConstructor() throws Exception {

    490. 

  490.     myFixture.addClass("""

    491. 

  491. class Point {

    492. 

  492.   Point() {}

    493. 

  493. }""")

    494. 

  494. 

    495. 

  495.     configureGppScript """

    496. 

  496. def foo(Point p) {}

    497. 

  497. Point p = [:]

    498. 

  498. Point p2 = [super:warning descr="Cannot find constructor of 'Point'">[4, 2]</warning>]

    499. 

  499. foo(<warning descr="Cannot find constructor of 'Point'">[4, 2]</warning>)

    500. 

  500. """

    501. 

  501.   }

    502. 

  502. 

    503. 

  503.   public void testResolveTraitMethod() throws Exception {

    504. 

  504.     configureScript """

    505. 

  505. @Trait

    506. 

  506. class Some {

    507. 

  507. 	public void doSmth() { println "hello" }

    508. 

  508. }

    509. 

  509. Some s

    510. 

  510. s.do<caret>Smth()

    511. 

  511. """

    512. 

  512.     assertEquals "doSmth", ((PsiMethod) findReference().resolve()).name

    513. 

  513.   }

    514. 

  514. 

    515. 

  515.   public void testBaseConstructorCallInMapLiteras() throws Exception {

    516. 

  516.     configureScript """

    517. 

  517. @Typed File foo() { <warning descr="Constructor 'File' in 'java.io.File' cannot be applied to '(['super':[java.lang.String]])'">['super':['a']]</warning> }

    518. 

  518. @Typed File goo() { <warning descr="Constructor 'File' in 'java.io.File' cannot be applied to '([:])'">[:]</warning> }

    519. 

  519. File bar() { <warning descr="Constructor 'File' in 'java.io.File' cannot be applied to '([:])'">[:]</warning> }

    520. 

  520. """

    521. 

  521.     myFixture.enableInspections new GroovyAssignabilityCheckInspection()

    522. 

  522.     myFixture.checkHighlighting(true, false, false)

    523. 

  523.   }

    524. 

  524. 

    525. 

  525.   public void testNestedLiteralConstructors() throws Exception {

    526. 

  526.     configureGppScript """

    527. 

  527.     class Foo {

    528. 

  528.       def Foo(Bar b) { }

    529. 

  529.     }

    530. 

  530. 

    531. 

  531.     class Bar {

    532. 

  532.       def Bar(int i) { }

    533. 

  533.     }

    534. 

  534. 

    535. 

  535.     Foo x = <warning descr="Constructor 'Foo' in 'Foo' cannot be applied to '([java.lang.Integer])'">[[2]]</warning>

    536. 

  536.     println x

    537. 

  537. """

    538. 

  538.     myFixture.enableInspections new GroovyAssignabilityCheckInspection()

    539. 

  539.     myFixture.checkHighlighting(true, false, false)

    540. 

  540.   }

    541. 

  541. 

    542. 

  542.   public void testNoReturnTypeInferenceInTypedContext() throws Exception {

    543. 

  543.     configureGppScript """

    544. 

  544. class Foo {

    545. 

  545.   def foo() { "aaa" }

    546. 

  546. }

    547. 

  547. new Foo().foo().substr<caret>a

    548. 

  548. """

    549. 

  549.     assertEmpty myFixture.completeBasic()

    550. 

  550.   }

    551. 

  551. 

    552. 

  552.   public void testDeclaredReturnTypeInTypedContext() throws Exception {

    553. 

  553.     configureGppScript """

    554. 

  554. class Foo {

    555. 

  555.   String getFoo() { "aaa" }

    556. 

  556. }

    557. 

  557. new Foo().foo.substr<caret>a

    558. 

  558. """

    559. 

  559.     myFixture.completeBasic()

    560. 

  560.     assertOrderedEquals myFixture.lookupElementStrings, "substring", "substring"

    561. 

  561.   }

    562. 

  562. 

    563. 

  563.   public void testNonInitializedVariable() throws Exception {

    564. 

  564.     configureScript """

    565. 

  565. 

    566. 

  566. @Typed

    567. 

  567. def foo() {

    568. 

  568.   int a

    569. 

  569.   return a

    570. 

  570. }

    571. 

  571. 

    572. 

  572. def bar() {

    573. 

  573.   int a

    574. 

  574.   return <warning descr="Variable 'a' might not be assigned">a</warning>

    575. 

  575. }"""

    576. 

  576.     myFixture.enableInspections new UnassignedVariableAccessInspection()

    577. 

  577.     myFixture.checkHighlighting(true, false, false)

    578. 

  578.   }

    579. 

  579. 

    580. 

  580.   public void testExternalizable() throws Exception {

    581. 

  581.     configureScript '''

    582. 

  582. @Typed class Foo implements Externalizable {}

    583. 

  583. <error descr="Method 'writeExternal' is not implemented">class Bar implements Externalizable</error> {}

    584. 

  584. '''

    585. 

  585.     myFixture.checkHighlighting(true, false, false)

    586. 

  586.   }

    587. 

  587. 

    588. 

  588.   public void testUsedInterceptors() {

    589. 

  589.     configureGppScript '''

    590. 

  590. class Bar {

    591. 

  591.   Object getUnresolvedProperty(String <warning descr="Parameter name is unused">name</warning>) {}

    592. 

  592.   Object <warning descr="Method getUnresolvedProperty is unused">getUnresolvedProperty</warning>(int <warning descr="Parameter name is unused">name</warning>) {}

    593. 

  593.   void setUnresolvedProperty(String <warning descr="Parameter name is unused">name</warning>, String <warning descr="Parameter value is unused">value</warning>) {}

    594. 

  594.   int invokeUnresolvedMethod(String <warning descr="Parameter name is unused">name</warning>, String <warning descr="Parameter arg1 is unused">arg1</warning>, boolean <warning descr="Parameter arg2 is unused">arg2</warning>, Object... <warning descr="Parameter args is unused">args</warning>) {}

    595. 

  595.   int invokeUnresolvedMethod(String <warning descr="Parameter name is unused">name</warning>, Object... <warning descr="Parameter args is unused">args</warning>) {}

    596. 

  596.   int <warning descr="Method invokeUnresolvedMethod is unused">invokeUnresolvedMethod</warning>(Object... <warning descr="Parameter args is unused">args</warning>) {}

    597. 

  597. }

    598. 

  598. println new Bar().zzz

    599. 

  599. '''

    600. 

  600.     myFixture.enableInspections(new GroovyUnusedDeclarationInspection(), new UnusedDeclarationInspection())

    601. 

  601.     myFixture.checkHighlighting(true, false, false)

    602. 

  602.   }

    603. 

  603. 

    604. 

  604. }

    605. 

  605. 

    606. 

  606. class GppProjectDescriptor extends DefaultLightProjectDescriptor {

    607. 

  607.   public static final instance = new GppProjectDescriptor()

    608. 

  608. 

    609. 

  609.   @Override

    610. 

  610.     public void configureModule(Module module, ModifiableRootModel model, ContentEntry contentEntry) {

    611. 

  611.     final Library.ModifiableModel modifiableModel = model.moduleLibraryTable.createLibrary("GROOVY++").modifiableModel;

    612. 

  612.     modifiableModel.addRoot(JarFileSystem.instance.refreshAndFindFileByPath(TestUtils.absoluteTestDataPath + "mockGroovypp/groovypp-0.9.0_1.8.2.jar!/"), OrderRootType.CLASSES)

    613. 

  613.     modifiableModel.addRoot(JarFileSystem.instance.refreshAndFindFileByPath(TestUtils.mockGroovy1_7LibraryName + "!/"), OrderRootType.CLASSES);

    614. 

  614.     modifiableModel.commit();

    615. 

  615.   }

    616. 

  616. }
    617.