Created module idea-test-framework and moved classes needed for idea tests there

Moved tests for completion and their test data into module idea-completion
2015-04-13 18:11:53 +03:00
parent 63825c45dd
commit bb808b5620
1303 changed files with 1741 additions and 1733 deletions
@@ -0,0 +1,11 @@
+fun String?.forNullableString(){}
+fun Any?.forNullableAny(){}
+fun String.forString(){}
+
+fun foo(s: String?) {
+    s.for<caret>
+}
+
+// ORDER: forNullableString
+// ORDER: forNullableAny
+// ORDER: forString
@@ -0,0 +1,38 @@
+fun aaGlobalFun(){}
+val aaGlobalProp = 1
+
+open class Base {
+    fun aaBaseFun(){}
+    val aaBaseProp = 1
+}
+
+class Derived : Base() {
+    fun aaDerivedFun(){}
+    val aaDerivedProp = 1
+
+    fun foo() {
+        val aaLocalVal = 1
+        fun aaLocalFun(){}
+
+        aa<caret>
+    }
+}
+
+fun Any.aAnyExtensionFun(){}
+fun Derived.aaExtensionFun(){}
+
+val Any.aAnyExtensionProp: Int get() = 1
+val Derived.aaExtensionProp: Int get() = 1
+
+// ORDER: aaLocalVal
+// ORDER: aaLocalFun
+// ORDER: aaDerivedProp
+// ORDER: aaDerivedFun
+// ORDER: aaBaseProp
+// ORDER: aaBaseFun
+// ORDER: aaExtensionProp
+// ORDER: aaExtensionFun
+// ORDER: aAnyExtensionProp
+// ORDER: aAnyExtensionFun
+// ORDER: aaGlobalProp
+// ORDER: aaGlobalFun
@@ -0,0 +1,9 @@
+fun foo1() {}
+deprecated("Use foo3 instead") fun foo2() {}
+fun foo3() {}
+
+fun test() {
+    foo<caret>
+}
+
+// ORDER: foo1, foo3, foo2
@@ -0,0 +1,10 @@
+fun test() {
+    val ifMore = true
+    val isFirst = true
+    if<caret>
+}
+
+// ORDER: if
+// ORDER: ifMore
+// ORDER: isFirst
+// SELECTED: 0
@@ -0,0 +1,9 @@
+package ppp
+
+fun prefixFun1(){}
+fun prefixFun2(){}
+fun prefixFun3(){}
+
+val prefixProp1: Int = 1
+val prefixProp2: Int = 1
+val prefixProp3: Int = 1
@@ -0,0 +1,12 @@
+import ppp.prefixFun2
+import ppp.prefixProp2
+
+val some = prefix<caret>
+
+// INVOCATION_COUNT: 2
+// ORDER: prefixProp2
+// ORDER: prefixProp1
+// ORDER: prefixProp3
+// ORDER: prefixFun2
+// ORDER: prefixFun1
+// ORDER: prefixFun3
@@ -0,0 +1,8 @@
+import java.sql.DriverPropertyInfo
+
+val some = Driver<caret>
+
+// INVOCATION_COUNT: 2
+// ORDER: Driver
+// ORDER: DriverPropertyInfo
+// ORDER: DriverManager
@@ -0,0 +1,4 @@
+package ppp1
+
+class MyClass1
+class MyClass2
@@ -0,0 +1,4 @@
+package ppp2
+
+class MyClass3
+class MyClass4
@@ -0,0 +1,4 @@
+package ppp3
+
+class MyClass5
+class MyClass6
@@ -0,0 +1,24 @@
+import ppp1.*
+import ppp3.MyClass6
+
+val v = My<caret>
+
+// INVOCATION_COUNT: 2
+
+/* explicitly imported */
+// ORDER: MyClass6
+
+/* imported with * */
+// ORDER: MyClass1
+
+/* imported with * */
+// ORDER: MyClass2
+
+/* another class from the same package imported */
+// ORDER: MyClass5
+
+/* not imported */
+// ORDER: MyClass3
+
+/* not imported */
+// ORDER: MyClass4
@@ -0,0 +1,6 @@
+fun main(variables: Array<String>) {
+    val values = ""
+    va<caret>
+}
+
+// ORDER: values, val, variables, var
@@ -0,0 +1,5 @@
+package some
+
+fun foo() = 12
+fun fooImported() = 12
+fun fooNotImported() = 12
@@ -0,0 +1,12 @@
+import some.fooImported
+
+val fooVar = 12
+fun fooLocal() = 12
+
+val some = foo<caret>
+
+// "foo" is before other elements because of exact prefix match
+
+// ORDER: foo, fooVar, fooLocal, fooImported, fooNotImported
+// INVOCATION_COUNT: 2
+// SELECTED: 0
@@ -0,0 +1,8 @@
+val initGlobal = 12
+
+fun test(initParam : Int) {
+    val initLocal = "Test"
+    init<caret>
+}
+
+// ORDER: initLocal, initParam, initGlobal
@@ -0,0 +1,6 @@
+fun test() {
+    val r = 12
+    r<caret>
+}
+
+// ORDER: r, return
@@ -0,0 +1,6 @@
+fun test(fals: Int) {
+    val falt = 111
+    fa<caret>
+}
+
+// ORDER: fals, falt, false
@@ -0,0 +1,10 @@
+package temp.test
+
+class Options(val listNew: Boolean, val listMatch: Boolean) {
+}
+
+fun listImportedFun() = 12
+val listImportedVal = 11
+
+
+
@@ -0,0 +1,22 @@
+package test
+
+import temp.test.*
+
+val listThisFileVal = 12
+fun listThisFileFun() = 1
+
+class ListThisFileClass {}
+
+fun test(listParam: Int) {
+    val listLocalVal = 12
+    Options(list<caret>)
+}
+
+// ORDER: listLocalVal
+// ORDER: listParam
+// ORDER: listThisFileVal
+// ORDER: listImportedVal
+// ORDER: listThisFileFun
+// ORDER: listImportedFun
+// ORDER: listMatch
+// ORDER: listNew
@@ -0,0 +1,5 @@
+fun bar(fop: Int) {
+    fo<caret>
+}
+
+// ORDER: fop, for
@@ -0,0 +1,21 @@
+val br1 = 11
+
+fun br() = 111
+
+class Test(val br2 = 12) {
+    val br3 = 13
+
+    fun brf() = 112
+
+    fun test(br4: Int) {
+        while (true) {
+            val br5 = 14
+            br<caret>
+        }
+    }
+}
+
+// "br" function is before other elements because of exact prefix match
+
+// ORDER: br, br4, br5, br2, br3, brf, br1, break
+// SELECTED: 0
@@ -0,0 +1,20 @@
+var nonNullable: Boolean = true
+
+var nullableX: Boolean? = null
+var nullableFoo: Boolean? = null
+
+fun foo(pFoo: Boolean, s: String) {
+    val local = true
+    foo(<caret>)
+}
+
+// ORDER: "pFoo, s"
+// ORDER: pFoo
+// ORDER: nullableFoo
+// ORDER: nullableFoo
+// ORDER: true
+// ORDER: false
+// ORDER: local
+// ORDER: nonNullable
+// ORDER: nullableX
+// ORDER: nullableX
@@ -0,0 +1,15 @@
+fun foo(filter: (String) -> Boolean) {}
+
+fun doFilter(s: String): Boolean = true
+fun x(s: String): Boolean = true
+
+fun bar(p: (String) -> Boolean) {
+    foo(<caret>)
+}
+
+// ORDER: ::doFilter
+// ORDER: p
+// ORDER: {...}
+// ORDER: { String -> ... }
+// ORDER: ::error
+// ORDER: ::x
@@ -0,0 +1,13 @@
+fun foo(xx: String){}
+
+fun bar(handler: (String) -> Unit){}
+
+fun f() {
+    val v = ""
+    val xx = ""
+    bar { foo(<caret>) }
+}
+
+// ORDER: xx
+// ORDER: it
+// ORDER: v
@@ -0,0 +1,8 @@
+fun foo(a: Int, b: String, c: String) {}
+
+fun bar(b: String, a: Int, c: String) {
+    foo(<caret>)
+}
+
+// ORDER: "a, b, c"
+// ORDER: a
@@ -0,0 +1,7 @@
+fun f(fooBar: String){}
+
+fun g(a: String, bar: String, fooBar: String) {
+    f(<caret>)
+}
+
+// ORDER: fooBar, bar, a
@@ -0,0 +1,7 @@
+fun f(fooBar: String){}
+
+fun g(fooA: String, someBar: String, fooBar: String, fooStuff: String) {
+    f(<caret>)
+}
+
+// ORDER: fooBar, someBar, fooA, fooStuff
@@ -0,0 +1,7 @@
+fun f(x: Int, fooBar1: String, fooBar2: String){}
+
+fun g(someBar0: String, someBar1: String, someBar2: String, fooBar: String, fooBar0: String, fooBar1: String, fooBar2: String) {
+    f(1, <caret>)
+}
+
+// ORDER: fooBar1, fooBar, fooBar0, fooBar2, someBar1, someBar0, someBar2
@@ -0,0 +1,10 @@
+val xId = ""
+val xP = ""
+val xP1 = ""
+
+fun g(zone: java.util.TimeZone) {
+    val xLocal = ""
+    zone.setID(x<caret>)
+}
+
+// ORDER: xLocal, xId, xP, xP1
@@ -0,0 +1,11 @@
+var fooBar = ""
+
+class C {
+    var bar = ""
+
+    fun foo(s: String) {
+        bar = <caret>
+    }
+}
+
+// ORDER: fooBar, s
@@ -0,0 +1,7 @@
+fun f(fooBar: String){}
+
+fun g(b: Boolean, a: String, foo: String, bar: String) {
+    f(if (b) { <caret> })
+}
+
+// ORDER: bar, foo, a
@@ -0,0 +1,7 @@
+fun f(fooBar: String){}
+
+fun g(b: Boolean, aaa: String, aaa1:String, foo: String, bar: String) {
+    f(if (b) aaa else <caret>)
+}
+
+// ORDER: bar, foo, aaa, aaa1
@@ -0,0 +1,11 @@
+fun f(fooBar: String){}
+
+object C {
+    fun aaa(): String = ""
+}
+
+fun g(b: Boolean, aaa: String, foo: String, bar: String) {
+    f(C.aaa() ?: <caret>)
+}
+
+// ORDER: bar, foo, aaa
@@ -0,0 +1,8 @@
+var fooBar1 = ""
+var fooBar2 = ""
+
+fun f(s: String){
+    if (fooBar1 == <caret>)
+}
+
+// ORDER: fooBar2, s
@@ -0,0 +1,11 @@
+class C {
+    var fooBar = ""
+}
+
+var fooBar = ""
+
+fun f(s: String, c: C){
+    if (c.fooBar == <caret>)
+}
+
+// ORDER: fooBar, s
@@ -0,0 +1,11 @@
+var fooBar = ""
+
+object C {
+    fun getFooBar() = ""
+}
+
+fun f(s: String){
+    if (C.getFooBar() == <caret>)
+}
+
+// ORDER: fooBar, s
@@ -0,0 +1,7 @@
+var fooBar = ""
+
+fun f(s: String, bars: List<String>){
+    if (bars[0] == <caret>)
+}
+
+// ORDER: fooBar, s
@@ -0,0 +1,5 @@
+val fooBar = ""
+
+fun foo(s: String): String = <caret>
+
+// ORDER: foo, fooBar, s
@@ -0,0 +1,11 @@
+class C(val x: X) {
+    val foo: String
+      get() = x.<caret>
+}
+
+class X {
+    val s = ""
+    fun getFoo() = ""
+}
+
+// ORDER: getFoo, s, toString
@@ -0,0 +1,13 @@
+class C(val x: X) {
+    val foo: String
+      get() {
+          return x.<caret>
+      }
+}
+
+class X {
+    val s = ""
+    fun getFoo() = ""
+}
+
+// ORDER: getFoo, s, toString
@@ -0,0 +1,9 @@
+var fooBar = ""
+
+class C {
+    fun foo(s: String) {
+        val bar: String = <caret>
+    }
+}
+
+// ORDER: fooBar, s
@@ -0,0 +1,7 @@
+val fooBar = ""
+
+fun foo(s: String): String {
+    return <caret>
+}
+
+// ORDER: foo, fooBar, s
@@ -0,0 +1,7 @@
+fun f(fooBar: String){}
+
+fun g(b: Boolean, a: String, foo: String, bar: String) {
+    f(if (b) <caret>)
+}
+
+// ORDER: bar, foo, a
@@ -0,0 +1,5 @@
+class A(s: String) {
+    val substring = s.<caret>capitalize()
+}
+
+// ORDER: substring
@@ -0,0 +1,13 @@
+// test that name similarity sorting takes over declaration kind sorting
+val xGlobalBar = ""
+val xGlobalX = ""
+
+fun f(fooBar: String){}
+
+fun g() {
+    val xLocalBar = ""
+    val xLocalX = ""
+    f(x<caret>)
+}
+
+// ORDER: xLocalBar, xGlobalBar, xLocalX, xGlobalX
@@ -0,0 +1,15 @@
+class Name {
+    companion object {
+        fun create(): Name = Name()
+    }
+}
+
+fun foo(name: Name){}
+
+fun bar() {
+    val v: (Name) -> Unit = { foo(<caret>) }
+}
+
+// ORDER: it
+// ORDER: Name
+// ORDER: create
@@ -0,0 +1,20 @@
+var global: C = C()
+
+abstract class C {
+    companion object {
+        val INSTANCE = C()
+    }
+}
+
+fun foo(p: C?) {
+    val local = C()
+    foo(<caret>)
+}
+
+
+// ORDER: p
+// ORDER: local
+// ORDER: global
+// ORDER: INSTANCE
+// ORDER: object
+// ORDER: null
@@ -0,0 +1,22 @@
+var nonNullable: C = C()
+
+class C {
+    var nullableX: C? = null
+    var nullableFoo: C? = null
+
+    fun foo(pFoo: C, s: String) {
+        val local = C()
+        foo(<caret>)
+    }
+}
+
+// ORDER: "pFoo, s"
+// ORDER: pFoo
+// ORDER: nullableFoo
+// ORDER: nullableFoo
+// ORDER: this
+// ORDER: local
+// ORDER: nonNullable
+// ORDER: nullableX
+// ORDER: nullableX
+// ORDER: C
@@ -0,0 +1,28 @@
+var nonNullable: C = C()
+var nullableX: C? = null
+var nullableFoo: C? = null
+
+abstract class C {
+    companion object {
+        val INSTANCE_X = C()
+        val INSTANCE_FOO = C()
+    }
+}
+
+fun foo(pFoo: C, s: String) {
+    val local = C()
+    foo(<caret>)
+}
+
+
+// ORDER: "pFoo, s"
+// ORDER: pFoo
+// ORDER: nullableFoo
+// ORDER: nullableFoo
+// ORDER: INSTANCE_FOO
+// ORDER: local
+// ORDER: nonNullable
+// ORDER: nullableX
+// ORDER: nullableX
+// ORDER: INSTANCE_X
+// ORDER: object
@@ -0,0 +1,16 @@
+class C {
+    companion object {
+        val INSTANCE = C()
+        fun create() = C()
+    }
+}
+
+fun foo(p: C) {
+    foo(<caret>)
+}
+
+
+// ORDER: p
+// ORDER: C
+// ORDER: INSTANCE
+// ORDER: create