add tests for private signatures

regenerate tests

add test for EnumEntry's argument declarations

add another test

regenerate test

fix test a bit
This commit is contained in:
Roman Artemev
2021-05-13 17:05:18 +03:00
committed by TeamCityServer
parent 2865d8bd45
commit 5a284de2d4
15 changed files with 665 additions and 0 deletions
@@ -0,0 +1,84 @@
// TARGET_BACKEND: JS
// MODULE: lib
// FILE: l.kt
fun foo(b: Boolean): String {
var result = ""
if (b) {
class LOuter<T1>(t1: T1) {
val stringOuter1: String = "A"
val genericOuter1: T1 = t1
private val test = object {
fun bar(a: Any = object {}) = object {
fun qux(a: Any = object {}) = object {
fun biq(a: Any = object {}) = object {
fun caz(a: Any = object {}) = object {
}.also { result += "d" }
}.also { result += "c" }
}.also { result += "b" }
}.also { result += "a" }
}.also { result += "!" }
private val ttt = test.bar()
private val qqq = ttt.qux()
val bbb = qqq.biq().also { it.caz() }
}
val lo = LOuter("Z")
result += lo.stringOuter1
result += lo.genericOuter1
} else {
class LOuter<T1>(t1: T1) {
val stringOuter2: String = "Z"
val genericOuter2: T1 = t1
private val test = object {
fun bar() = object {
fun qux() = object {
fun biq() = object {
fun caz() = object {
}.also { result += "h" }
}.also { result += "g" }
}.also { result += "f" }
}.also { result += "e" }
}.also { result += "?" }
private val ttt = test.bar()
private val qqq = ttt.qux()
val bbb = qqq.biq().also { it.caz() }
}
val lo = LOuter(1)
result += lo.stringOuter2
result += lo.genericOuter2
}
return result
}
// MODULE: main(lib)
// FILE: m.kt
fun box(): String {
val r1 = foo(true)
if (r1 != "!abcdAZ") return "FAIL1: $r1"
val r2 = foo(false)
if (r2 != "?efghZ1") return "FAIL2: $r2"
return "OK"
}
@@ -0,0 +1,79 @@
// TARGET_BACKEND: JS
// MODULE: lib
// FILE: l.kt
fun foo(b: Boolean): String {
var result = ""
if (b) {
class L1<T1>(val t1: T1) {
fun <F1> foo(f1: F1): String {
class L2<T2>(tx1: T1, fx1: F1, t2: T2) {
init {
result += tx1
result += fx1
result += t2
}
fun <F2> qux(f2: F2): String {
class L3<T3>(val t3: T3) {
val d by lazy { "F" + t3 }
}
return L3("E").d + f2
}
}
return L2(t1, f1, "C").qux("D")
}
}
val tmp = L1("A").foo("B")
result += tmp
} else {
class L1<T1>(val t1: T1) {
fun <F1> foo(f1: F1): String {
class L2<T2>(t1: T1, f1: F1, t2: T2) {
init {
result += t1
result += f1
result += t2
}
fun <F2> qux(f2: F2): String {
class L3<T3>(val t3: T3) {
val e by lazy { "Z" + t3 }
}
return L3(5).e + f2
}
}
return L2(t1, f1, 3).qux(4)
}
}
val tmp = L1(1).foo(2)
result += tmp
}
return result
}
// MODULE: main(lib)
// FILE: m.kt
fun box(): String {
val r1 = foo(true)
if (r1 != "ABCFED") return "FAIL1: $r1"
val r2 = foo(false)
if (r2 != "123Z54") return "FAIL2: $r2"
return "OK"
}
@@ -0,0 +1,66 @@
// TARGET_BACKEND: JS
// MODULE: lib
// FILE: l.kt
fun foo(b: Boolean): String {
var result = ""
if (b) {
class L1(private val v: String) {
open fun foo(
block: () -> String = {
class L2 {
fun foo(
block2: () -> String = { "A" }
): String = block2()
}
L2().foo()
}
): String {
return block() + v
}
}
result += L1("B").foo()
} else {
class L1(private val v: Int) {
open fun foo(
block: () -> String = {
class L2 {
fun foo(
block2: () -> Int = { 42 }
): String = "" + block2()
}
L2().foo()
}
): String {
return block() + v
}
}
result += L1(71).foo()
}
return result
}
// MODULE: main(lib)
// FILE: main.kt
fun box(): String {
val r1 = foo(true)
if (r1 != "AB") return "FAIL1: $r1"
val r2 = foo(false)
if (r2 != "4271") return "FAIL2: $r2"
return "OK"
}
@@ -0,0 +1,86 @@
// TARGET_BACKEND: JS
// MODULE: lib
// FILE: l.kt
fun foo(b: Boolean): String {
var result = ""
if (b) {
open class L1() {
open fun foo(): String {
return "B"
}
fun test1(): String {
open class L2 : L1() {
fun test2(): String {
class L3: L2() {
override fun foo(): String = "O"
}
return foo() + L3().foo()
}
}
return foo() + L2().test2()
}
}
result += L1().test1()
return result
} else {
open class L1() {
open fun bar(): Int {
return 42
}
fun test1(): String {
open class L2 : L1() {
fun test2(): String {
class L3: L2() {
override fun bar(): Int = 71
}
return "" + bar() + "" + L3().bar()
}
}
return "" + bar() + L2().test2()
}
}
result += L1().test1()
}
return result
}
// MODULE: main(lib)
// FILE: main.kt
fun box(): String {
val r1 = foo(true)
if (r1 != "BBO") return "FAIL1: $r1"
val r2 = foo(false)
if (r2 != "424271") return "FAIL2: $r2"
return "OK"
}
@@ -0,0 +1,41 @@
// SKIP_MANGLE_VERIFICATION
// MODULE: lib
// FILE: l.kt
interface I {
fun foo(): String
}
enum class E(val i: I, val l: () -> String) {
A(object : I {
override fun foo(): String = "AI"
}, { "AL" }) ,
B(object : I {
override fun foo(): String = "BI"
}, { "BL" }),
C(object : I {
override fun foo(): String = "CI"
}, { "CL" })
}
// MODULE: main(lib)
// FILE: m.kt
fun box(): String {
var result = ""
result += E.A.i.foo()
result += E.A.l()
result += E.B.i.foo()
result += E.B.l()
result += E.C.i.foo()
result += E.C.l()
if (result != "AIALBIBLCICL") return "FAIL: $result"
return "OK"
}
@@ -0,0 +1,52 @@
// TARGET_BACKEND: JS
// MODULE: lib
// FILE: l.kt
var result = ""
fun foo(b: Boolean) {
class P1
abstract class A1 {
fun bar(p1: P1): String = "AB"
abstract fun qux(): String
}
if (b) {
class C1 : A1() {
override fun qux(): String = "C1T"
}
val c1 = C1()
result += c1.qux()
result += c1.bar(P1())
} else {
class C1 : A1() {
override fun qux(): String = "C1F"
}
val c1 = C1()
result += c1.qux()
result += c1.bar(P1())
}
}
fun r(): String = result
// MODULE: main(lib)
// FILE: m.kt
fun box(): String {
foo(true)
foo(false)
val rr = r()
if (rr != "C1TABC1FAB") return "FAIL: $rr"
return "OK"
}
@@ -0,0 +1,29 @@
// TARGET_BACKEND: JS
// MODULE: lib
// FILE: l1.kt
package lib
private val d by lazy { "O" }
fun o() = d
// FILE: l2.kt
package lib
private val d by lazy { "K" }
fun k() = d
// MODULE: main(lib)
// FILE: main.kt
package main
import lib.*
fun box(): String = o() + k()