remove gpp tests

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

@@ -1,64 +0,0 @@
-/*
- * Copyright 2000-2014 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 org.jetbrains.plugins.groovy.lang
-
-import com.intellij.psi.PsiReference
-import com.intellij.testFramework.LightProjectDescriptor
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.jetbrains.annotations.NotNull
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrGdkMethod
-
-/**
- * @author peter
- */
-class GppCategoryTest extends LightCodeInsightFixtureTestCase {
-  @NotNull
-  @Override
-  protected LightProjectDescriptor getProjectDescriptor() {
-    return GppProjectDescriptor.instance
-  }
-
-  public void testFromSuperClassClosureSyntax() {
-    assertResolves """
-abstract class Super implements Runnable {
-  static def category(Object foo, int bar) {}
-}
-
-Super s = { "".cate<caret>gory(2) }
-"""
-  }
-
-  public void testFromSuperClassMapSyntax() {
-    assertResolves """
-class Super {
-  static def category(Object foo, int bar) {}
-  void xxx() {}
-}
-
-Super s = [xxx:{ "".cate<caret>gory(2) }]
-"""
-  }
-
-  private def assertResolves(String text) {
-    myFixture.configureByText "a.gpp", text
-    assert findReference().resolve() instanceof GrGdkMethod
-  }
-
-  private PsiReference findReference() {
-    return myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)
-  }
-
-}

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

@@ -1,499 +0,0 @@
-/*
- * Copyright 2000-2014 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 org.jetbrains.plugins.groovy.lang
-
-import com.intellij.codeInsight.lookup.LookupManager
-import com.intellij.codeInspection.deadCode.UnusedDeclarationInspectionBase
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.roots.ContentEntry
-import com.intellij.openapi.roots.ModifiableRootModel
-import com.intellij.openapi.roots.OrderRootType
-import com.intellij.openapi.roots.libraries.Library
-import com.intellij.openapi.vfs.JarFileSystem
-import com.intellij.psi.*
-import com.intellij.testFramework.LightProjectDescriptor
-import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import junit.framework.ComparisonFailure
-import org.jetbrains.annotations.NotNull
-import org.jetbrains.plugins.groovy.codeInspection.GroovyUnusedDeclarationInspection
-import org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignabilityCheckInspection
-import org.jetbrains.plugins.groovy.codeInspection.unassignedVariable.UnassignedVariableAccessInspection
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod
-import org.jetbrains.plugins.groovy.util.TestUtils
-
-/**
- * @author peter
- */
-class GppFunctionalTest extends LightCodeInsightFixtureTestCase {
-
-  @NotNull
-  @Override
-  protected LightProjectDescriptor getProjectDescriptor() {
-    return GppProjectDescriptor.instance;
-  }
-
-  protected void setUp() {
-    super.setUp()
-  }
-
-  public void testCastListToIterable() throws Exception {
-    myFixture.addClass("class X extends java.util.ArrayList<Integer> {}")
-    testAssignability """
-X ints = [239, 4.2d]
-"""
-  }
-
-  public void testCastListToAnything() throws Exception {
-    testAssignability """
-File f1 = ['path']
-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>
-"""
-  }
-
-  public void testCastMapToAnotherMap() throws Exception {
-    myFixture.addClass """
-public class Y extends java.util.HashMap<String, String> {
-  public Y(int initialCapacity) {
-    super(initialCapacity);
-  }
-}
-"""
-
-    testAssignability """
-HashMap<String, File> m1 = ['a':['b']]
-Y y = <warning descr="Constructor 'Y' in 'Y' cannot be applied to '(['a':java.lang.String])'">[a:'b']</warning>
-"""
-  }
-
-  public void testAnonymousClass() throws Exception {
-    myFixture.enableInspections new GroovyAssignabilityCheckInspection()
-    testAssignability """
-def x = new Object() {
-  def foo() {
-    HashMap<String, File> m1 = ['a':['b']]
-    HashMap<String, File> <warning descr="Cannot assign 'File' to 'HashMap<String, File>'">m2</warning> = new File('aaa')
-  }
-}
-"""
-  }
-
-  public void testCastMapToObject() throws Exception {
-    myFixture.addClass("class Foo { String name; void foo() {} }")
-    testAssignability """
-Foo f = [name: 'aaa', foo: { println 'hi' }, anotherProperty: 42 ]
-"""
-  }
-
-  void testAssignability(String text) {
-    myFixture.enableInspections new GroovyAssignabilityCheckInspection()
-    PsiFile file = configureGppScript(text)
-    myFixture.testHighlighting(true, false, false, file.virtualFile)
-  }
-
-  private PsiFile configureScript(String text) {
-    return myFixture.configureByText("a.groovy", text)
-  }
-  private PsiFile configureGppScript(String text) {
-    return myFixture.configureByText("a.gpp", text)
-  }
-
-  public void testDeclaredVariableTypeIsMoreImportantThanTheInitializerOne() throws Exception {
-    configureScript("""
-File f = ['path']
-f.mk<caret>
-""")
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "mkdir", "mkdirs"
-  }
-
-  public void testDeclaredVariableTypeIsMoreImportantThanTheInitializerOne2() throws Exception {
-    myFixture.addClass """
-public class Some {
-    public int prop
-
-    public void f_foo() {}
-    public void f_bar() {}
-}
-"""
-
-    configureScript("""
-Some s = [prop: 239]
-s.f_<caret>
-""")
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "f_foo", "f_bar"
-  }
-
-  public void testResolveMethod() throws Exception {
-    myFixture.configureByText("a.groovy", """
-def foo(File f) {}
-@Typed def bar() {
-  fo<caret>o(['path'])
-}
-""")
-    def reference = findReference()
-    def target = reference.resolve()
-    assertEquals "foo", ((GrMethod)target).name
-  }
-
-  private PsiReference findReference() {
-    return myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)
-  }
-
-  public void testOverloadingWithConversion() throws Exception {
-    myFixture.configureByText("a.groovy", """
-def foo(List l) {}
-def foo(File f) {}
-@Typed def bar() {
-  fo<caret>o(['path'])
-}
-""")
-    def reference = findReference()
-    def target = reference.resolve()
-    assertNotNull target
-    assert target.text.contains("List l")
-  }
-
-  public void testWrongProperty() throws Exception {
-myFixture.configureByText 'a.gpp', '''
-class ClassA {
-  def prop = 2
-  def bar() {
-    def t = new Object()
-    t.pr<caret>op
-  }
-}'''
-    assert !findReference().resolve()
-  }
-
-  public void testCastClosureToOneMethodClass() throws Exception {
-    myFixture.addClass """
-public abstract class Foo {
-  public abstract void foo(String s);
-  public abstract void bar(String s);
-}
-public interface Action {
-  void act();
-}
-"""
-
-    testAssignability """
-Foo <warning descr="Cannot assign 'Closure' to 'Foo'">f</warning> = { println it }
-Function1<String, Object> f1 = { println it }
-Function1<String, Object> f2 = { x=42 -> println x }
-Function1<String, Object> <warning descr="Cannot assign 'Closure' to 'Function1<String, Object>'">f3</warning> = { int x -> println x }
-Runnable r = { println it }
-Action a = { println it }
-Action a1 = { a2 = 2 -> println a2 }
-"""
-  }
-
-  public void testClosureParameterTypesInAssignment() throws Exception {
-    configureScript "Function1<String, Object> f = { it.subs<caret> }"
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"
-  }
-
-  public void testClosureParameterTypesInMethodInvocation() throws Exception {
-    myFixture.configureByText "a.groovy", """
-def foo(int a = 1, Function1<String, Object> f) {}
-def foo(String s) {}
-def foo(Function2<Integer, String, Object> f) {}
-
-@Typed def bar() {
-  foo { it.subsREF }
-  foo(1, { it.subsREF })
-  foo 1, { it.subsREF }
-  foo(1) { it.subsREF }
-  foo { a -> a.subsREF }
-  foo { a, int b=2 -> a.subsREF }
-  foo { a, b -> b.subsREF }
-}
-"""
-    def text = myFixture.file.text
-    def pos = 0
-    while (true) {
-      pos = text.indexOf("REF", pos+1)
-      if (pos < 0) {
-        break
-      }
-      myFixture.editor.caretModel.moveToOffset pos
-      myFixture.completeBasic()
-      try {
-        assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"
-      }
-      catch (ComparisonFailure ex) {
-        println "at: " + text[0..<pos] + "<caret>" + text[pos..<text.size()]
-        throw ex
-      }
-      LookupManager.getInstance(project).hideActiveLookup()
-    }
-  }
-
-  public void testReturnTypeOneMethodInterface() throws Exception {
-    myFixture.configureByText "a.groovy", """
-@Typed Function1<String, Integer> bar() {
-   { it.subs<caret> }
-}
-"""
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"
-  }
-
-  public void testClosureInMapInstantiation() throws Exception {
-    myFixture.configureByText "a.groovy", """
-class Foo<T> {
-  int foo(T a) {}
-}
-
-@Typed Foo<String> bar() {
-    return [foo: { it.subs<caret> }]
-}
-"""
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"
-  }
-
-  public void testClosureInMapInstantiationBoxPrimitives() throws Exception {
-    myFixture.configureByText "a.groovy", """
-class Foo {
-  int foo(int a) {}
-}
-
-@Typed Foo bar() {
-    return [foo: { it.intV<caret>V }]
-}
-"""
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "intValue"
-  }
-
-  public void testClosureInListInstantiation() throws Exception {
-    myFixture.configureByText "a.groovy", """
-class Foo {
-  def Foo(int a, Function1<String, Integer> f) {}
-}
-
-@Typed Foo foo() {
-  [239, { s -> s.subs<caret> }]
-}
-"""
-    myFixture.completeBasic()
-    assertSameElements myFixture.lookupElementStrings, "subSequence", "substring", "substring"
-  }
-
-  private PsiElement resolveReference() {
-    return findReference().resolve()
-  }
-
-  public void testResolveToSuperMethodClosureSyntax() {
-    configureScript """
-abstract class Super implements Runnable {
-  def method(int bar) {}
-}
-
-Super s = { <caret>method(2) } as Super
-"""
-    assert resolveReference() instanceof GrMethod
-  }
-
-  public void testGotoSuperMethodFromMapLiterals() throws Exception {
-    PsiClass point = myFixture.addClass("""
-class Point {
-  Point() {}
-  Point(int y) {}
-  int y;
-  void setX(int x) {}
-  void move(int x, int y) {}
-  void move(int y) {}
-}""")
-
-    configureScript "Point p = [<caret>y:2]"
-    assertEquals point.findFieldByName("y", false), resolveReference()
-
-    configureScript "Point p = [<caret>x:2]"
-    assertEquals point.findMethodsByName("setX", false)[0], resolveReference()
-
-    configureScript "Point p = [mo<caret>ve: { x, y -> z }]"
-    assertEquals point.findMethodsByName("move", false)[0], resolveReference()
-
-    configureScript "Point p = [mo<caret>ve: ]"
-    def resolveResults = multiResolveReference()
-    assertSameElements resolveResults.collect { it.element }, point.findMethodsByName("move", false)
-  }
-
-  ResolveResult[] multiResolveReference() {
-    final PsiReference ref = myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)
-    assertNotNull(ref)
-    assertInstanceOf(ref, PsiPolyVariantReference)
-    return ((PsiPolyVariantReference)ref).multiResolve(true)
-  }
-
-  public void testGotoSuperConstructorFromMapLiterals() throws Exception {
-    PsiClass point = myFixture.addClass("""
-class Point {
-  Point() {}
-  Point(int y) {}
-}""")
-
-    configureGppScript "Point p = [su<caret>per: 2]"
-    assertEquals point.constructors[1], resolveReference()
-
-    configureGppScript "Point p = [su<caret>per: [2]]"
-    assertEquals point.constructors[1], resolveReference()
-
-    configureGppScript "Point p = ['su<caret>per': []]"
-    assertEquals point.constructors[0], resolveReference()
-
-    configureGppScript "Point p = ['su<caret>per': 'a']"
-    assertEquals 1, multiResolveReference().size()
-  }
-
-  public void testGotoClassFromLiteralOnsetsWhenNoConstructorsPresent() throws Exception {
-    PsiClass point = myFixture.addClass(""" class Point { }""")
-    configureGppScript "Point p = <caret>[super: 2]"
-    assertEquals point, resolveReference()
-
-    configureGppScript "Point p = <caret>[]"
-    assertEquals point, resolveReference()
-  }
-
-  public void testNoGotoObjectFromLiteral() throws Exception {
-    myFixture.addClass(""" class Point { }""")
-
-    configureGppScript "def p = <caret>[]"
-    assertNull findReference().resolve()
-  }
-
-  public void testHighlightInapplicableLiteralConstructor() throws Exception {
-    myFixture.addClass("""
-class Point {
-  Point() {}
-}""")
-
-    configureGppScript """
-def foo(Point p) {}
-Point p = [:]
-Point p2 = [super:warning descr="Cannot find constructor of 'Point'">[4, 2]</warning>]
-foo(<warning descr="Cannot find constructor of 'Point'">[4, 2]</warning>)
-"""
-  }
-
-  public void testResolveTraitMethod() throws Exception {
-    configureScript """
-@Trait
-class Some {
-	public void doSmth() { println "hello" }
-}
-Some s
-s.do<caret>Smth()
-"""
-    assertEquals "doSmth", ((PsiMethod) findReference().resolve()).name
-  }
-
-  public void testNestedLiteralConstructors() throws Exception {
-    configureGppScript """
-    class Foo {
-      def Foo(Bar b) { }
-    }
-
-    class Bar {
-      def Bar(int i) { }
-    }
-
-    Foo x = <warning descr="Constructor 'Foo' in 'Foo' cannot be applied to '([java.lang.Integer])'">[[2]]</warning>
-    println x
-"""
-    myFixture.enableInspections new GroovyAssignabilityCheckInspection()
-    myFixture.checkHighlighting(true, false, false)
-  }
-
-  public void testNoReturnTypeInferenceInTypedContext() throws Exception {
-    configureGppScript """
-class Foo {
-  def foo() { "aaa" }
-}
-new Foo().foo().substr<caret>a
-"""
-    assertEmpty myFixture.completeBasic()
-  }
-
-  public void testDeclaredReturnTypeInTypedContext() throws Exception {
-    configureGppScript """
-class Foo {
-  String getFoo() { "aaa" }
-}
-new Foo().foo.substr<caret>a
-"""
-    myFixture.completeBasic()
-    assertOrderedEquals myFixture.lookupElementStrings, "substring", "substring"
-  }
-
-  public void testNonInitializedVariable() throws Exception {
-    configureScript """
-
-@Typed
-def foo() {
-  int a
-  return a
-}
-
-def bar() {
-  int a
-  return <warning descr="Variable 'a' might not be assigned">a</warning>
-}"""
-    myFixture.enableInspections new UnassignedVariableAccessInspection()
-    myFixture.checkHighlighting(true, false, false)
-  }
-
-  public void testExternalizable() throws Exception {
-    configureScript '''
-@Typed class Foo implements Externalizable {}
-<error descr="Method 'writeExternal' is not implemented">class Bar implements Externalizable</error> {}
-'''
-    myFixture.checkHighlighting(true, false, false)
-  }
-
-  public void testUsedInterceptors() {
-    configureGppScript '''
-class Bar {
-  Object getUnresolvedProperty(String <warning descr="Parameter name is unused">name</warning>) {}
-  Object <warning descr="Method getUnresolvedProperty is unused">getUnresolvedProperty</warning>(int <warning descr="Parameter name is unused">name</warning>) {}
-  void setUnresolvedProperty(String <warning descr="Parameter name is unused">name</warning>, String <warning descr="Parameter value is unused">value</warning>) {}
-  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>) {}
-  int invokeUnresolvedMethod(String <warning descr="Parameter name is unused">name</warning>, Object... <warning descr="Parameter args is unused">args</warning>) {}
-  int <warning descr="Method invokeUnresolvedMethod is unused">invokeUnresolvedMethod</warning>(Object... <warning descr="Parameter args is unused">args</warning>) {}
-}
-println new Bar().zzz
-'''
-    myFixture.enableInspections(new GroovyUnusedDeclarationInspection(), new UnusedDeclarationInspectionBase(true))
-    myFixture.checkHighlighting(true, false, false)
-  }
-
-}
-
-class GppProjectDescriptor extends DefaultLightProjectDescriptor {
-  public static final instance = new GppProjectDescriptor()
-
-  @Override
-    public void configureModule(Module module, ModifiableRootModel model, ContentEntry contentEntry) {
-    final Library.ModifiableModel modifiableModel = model.moduleLibraryTable.createLibrary("GROOVY++").modifiableModel;
-    modifiableModel.addRoot(JarFileSystem.instance.refreshAndFindFileByPath(TestUtils.absoluteTestDataPath + "mockGroovypp/groovypp-0.9.0_1.8.2.jar!/"), OrderRootType.CLASSES)
-    modifiableModel.addRoot(JarFileSystem.instance.refreshAndFindFileByPath(TestUtils.mockGroovy1_7LibraryName + "!/"), OrderRootType.CLASSES);
-    modifiableModel.commit();
-  }
-}

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

@@ -28,37 +28,6 @@ class LiteralConstructorUsagesTest extends LightGroovyTestCase {
     null
   }
 
-  @Override
-  protected void setUp() {
-    super.setUp();
-    myFixture.addClass("package groovy.lang; public @interface Typed {}");
-  }
-
-  public void testList_Variable() throws Exception {
-    def foo = myFixture.addClass("""class Foo {
-    Foo() {}
-    }
-""")
-    myFixture.addFileToProject "a.gpp", "Foo x = []"
-    assertOneElement(ReferencesSearch.search(foo.constructors[0]).findAll())
-  }
-
-  public void testList_ReturnValue() throws Exception {
-    def foo = myFixture.addClass("""class Foo {
-    Foo() {}
-    }
-""")
-    myFixture.addFileToProject "a.groovy", """
-@Typed Foo foo() {
-  if (true) []
-  else return []
-}
-Foo untyped() { [] }
-@Typed Foo bar() { [] }
-"""
-    assertEquals(4, ReferencesSearch.search(foo.constructors[0]).findAll().size())
-  }
-
   public void testList_AsCast() throws Exception {
     def foo = myFixture.addClass("""class Foo {
     Foo() {}
@@ -77,59 +46,6 @@ Foo untyped() { [] }
     assertOneElement(ReferencesSearch.search(foo.constructors[0]).findAll())
   }
 
-  public void testMapSuper_AsCast() throws Exception {
-    def foo = myFixture.addClass("""class Foo {
-    Foo(int a) {}
-    }
-}""")
-    myFixture.addFileToProject "a.gpp", "def x = ['super':[2]] as Foo"
-    myFixture.addFileToProject "c.gpp", "def x = [super:2] as Foo"
-
-    assertEquals(2, ReferencesSearch.search(foo.constructors[0]).findAll().size())
-  }
-
-  public void testOverloadedConstructorUsages() throws Exception {
-    def foo = myFixture.addClass("""
-      class Foo {
-          Foo() {}
-          Foo(int a) {}
-      }
-      """)
-
-    myFixture.addFileToProject "a.gpp", """
-      Foo b = []
-      Foo b1 = [2]
-      """
-    assertEquals(2, MethodReferencesSearch.search(foo.constructors[0], false).findAll().size())
-    assertEquals(2, MethodReferencesSearch.search(foo.constructors[1], false).findAll().size())
-  }
-
-  public void testLiteralWithinALiteral() throws Exception {
-    myFixture.addFileToProject "a.gpp", """
-class Foo {
-  Foo(Bar b) {}
-}
-
-class Bar {
-  Bar(String s) {}
-}
-
-Foo f = [new Bar('a')]
-Foo f2 = ['super':['super':'a']]
-"""
-    assertEquals 1, MethodReferencesSearch.search(myFixture.findClass("Bar").constructors[0]).findAll().size()
-  }
-
-  public void testCannibalisticConstructor() throws Exception {
-    myFixture.addFileToProject "a.gpp", """
-      class Foo {
-        Foo(Foo... children) {}
-      }
-      Foo f = [new Foo('a')]
-    """
-    assertEquals 2, MethodReferencesSearch.search(myFixture.findClass("Foo").constructors[0]).findAll().size()
-  }
-
   void testLiteralConstructorWithNamedArgs() {
     addLinkedHashMap()
     myFixture.addFileToProject "a.groovy", """\