[Test] Merge box against java testdata into codegen black box testsdata

2021-01-27 16:21:31 +03:00
parent e62b118351
commit 3199ce03a6
165 changed files with 0 additions and 3948 deletions
@@ -0,0 +1,40 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public interface Super1<T> {
+        Thread call(T t);
+    }
+
+    public interface Super2<T> {
+        T call(String s);
+    }
+
+    public interface Sub extends Super1<String>, Super2<Thread> {
+        Thread call(String s);
+    }
+
+    static void samAdapter(Sub sub) {
+        ((Super1) sub).call("");
+        ((Super2) sub).call("");
+        sub.call("");
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String? {
+    var s: String?
+    s = "FAIL for function literal"
+    JavaClass.samAdapter { s = "OK"; null }
+    if (s != "OK") return s
+
+    s = "FAIL for wrapper"
+    val function: (String?) -> Thread? = { s = "OK"; null }
+    JavaClass.samAdapter(function)
+    if (s != "OK") return s
+
+    return "OK"
+}
@@ -0,0 +1,31 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+// KT-5912
+class JavaClass<T> {
+    public static interface Action<T> {
+        void call(T t);
+    }
+
+    public static class Some<T> {
+        public Some(T t) {
+        }
+    }
+
+    public static interface OnSubscribe<T> extends Action<Some<T>> {}
+
+    void perform(T t, OnSubscribe<T> subscribe) {
+        subscribe.call(new Some(t));
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+// KT-5912
+fun box(): String {
+    var s = "Failt"
+    JavaClass<String>().perform("") { s = "OK" }
+    return s
+}
@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaInterface.java
+
+interface JavaInterface {
+    void run(Runnable r);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class Impl: JavaInterface {
+    override fun run(r: Runnable?) {
+        r?.run()
+    }
+}
+
+fun box(): String {
+    var v = "FAIL"
+    Impl().run { v = "OK" }
+    return v
+}
@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.*;
+
+class JavaClass {
+    public static void sortIntList(List<Integer> list, Comparator<Integer> comparator) {
+        Collections.sort(list, comparator);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.*
+
+fun box(): String {
+    val list = ArrayList(Arrays.asList(3, 2, 4, 8, 1, 5))
+    val expected = ArrayList(Arrays.asList(8, 5, 4, 3, 2, 1))
+    JavaClass.sortIntList(list, { a, b -> b - a })
+    return if (list == expected) "OK" else list.toString()
+}
@@ -0,0 +1,24 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    JavaClass { v = "OK" }.run()
+    return v
+}
@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: GenericInterface.java
+
+interface GenericInterface<T> {
+    public T foo(double d, int i, long j, short s);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal fun getInterface(): GenericInterface<String> {
+    return GenericInterface { d, i, j, s ->
+        "OK"
+    }
+}
+
+fun box(): String {
+    return getInterface().foo(0.0, 0, 0, 0)
+}
@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.io.*;
+
+class JavaClass {
+    public static String invokeFilter(FileFilter f, File file1, File file2) {
+        return f.accept(file1) + " " + f.accept(file2);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.io.*
+
+fun box(): String {
+    val ACCEPT_NAME = "test"
+    val WRONG_NAME = "wrong"
+
+    val result = JavaClass.invokeFilter({ file -> ACCEPT_NAME == file?.getName() }, File(ACCEPT_NAME), File(WRONG_NAME))
+
+    if (result != "true false") return "Wrong result: $result"
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+class JavaClass {
+    public static String foo(Comparator<String> comparator) {
+        return Arrays.toString(comparator.getClass().getGenericInterfaces());
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val supertypes = JavaClass.foo { a, b -> a.compareTo(b) }
+    if (supertypes != "[java.util.Comparator<java.lang.String>]") return "Fail: $supertypes"
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaInterface.java
+
+interface JavaInterface {
+    void foo(Runnable r);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class Impl: JavaInterface {
+    override fun foo(r: Runnable?) {
+        r?.run()
+    }
+}
+
+fun box(): String {
+    val fooMethods = Impl::class.java.getMethods().filter { it.getName() == "foo" }
+    if (fooMethods.size != 1) return fooMethods.toString()
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public void run(Runnable r) {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal class KotlinSubclass: JavaClass() {
+}
+
+fun box(): String {
+    var v = "FAIL"
+    KotlinSubclass().run { v = "OK" }
+    return v
+}
@@ -0,0 +1,44 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Super.java
+
+class Super {
+    public String lastCalled = null;
+
+    void foo(Runnable r) {
+        lastCalled = "super";
+    }
+}
+
+// FILE: Sub.java
+
+import kotlin.jvm.functions.Function0;
+import kotlin.Unit;
+
+class Sub extends Super {
+    void foo(Function0<Unit> r) {
+        lastCalled = "sub";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val sub = Sub()
+    val sup: Super = sub
+
+    sup.foo{ }
+    if (sub.lastCalled != "super") {
+        return "FAIL: ${sub.lastCalled} instead of super"
+    }
+
+    sub.foo{ }
+    if (sub.lastCalled != "sub") {
+        return "FAIL: ${sub.lastCalled} instead of sub"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Sub.java
+
+class Super {
+    void safeInvoke(Runnable r) {
+        if (r != null) r.run();
+    }
+}
+
+class Sub extends Super {
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var r = "FAIL"
+    val sub = Sub()
+    sub.safeInvoke(null)
+    sub.safeInvoke { r = "OK" }
+    return r
+}
@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+var status: String = "fail"  // global property to avoid issues with accessing closure from local class (KT-4174)
+
+fun box(): String {
+    class C() : JavaClass({status = "OK"}) {}
+    C().run()
+    return status
+}
@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val x = object : JavaClass({-> v = "OK"}) {}
+    x.run()
+    return v
+}
@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = {-> v = "OK"}
+    val x = object : JavaClass(f) {}
+    x.run()
+    return v
+}
@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static void run(Runnable r1, Runnable r2) {
+        r1.run();
+        r2.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = { v = "O" }
+    JavaClass.run(f, { v += "K" })
+    return v
+}
@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.*;
+
+class JavaClass {
+    public static void sortIntList(List<Integer> list, Comparator<Integer> comparator) {
+        Collections.sort(list, comparator);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.*
+
+fun box(): String {
+    val list = ArrayList(Arrays.asList(3, 2, 4, 8, 1, 5))
+    val expected = ArrayList(Arrays.asList(8, 5, 4, 3, 2, 1))
+
+    val f = { a: Int, b: Int -> b - a }
+    JavaClass.sortIntList(list, f)
+    return if (list == expected) "OK" else list.toString()
+}
@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = { v = "OK" }
+    JavaClass(f).run()
+    return v
+}
@@ -0,0 +1,17 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static String run(Runnable r) {
+        return r == null ? "OK" : "FAIL";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val f: (() -> Unit)? = null
+    return JavaClass.run(f)!!
+}
@@ -0,0 +1,19 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static void run(Runnable r) {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = { v = "OK" }
+    JavaClass.run(f)
+    return v
+}
@@ -0,0 +1,54 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    void plusAssign(Runnable i) {
+        i.run();
+    }
+
+    void minusAssign(Runnable i) {
+        i.run();
+    }
+
+    void timesAssign(Runnable i) {
+        i.run();
+    }
+
+    void divAssign(Runnable i) {
+        i.run();
+    }
+
+    void remAssign(Runnable i) {
+        i.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj += { v1 = "OK" }
+    if (v1 != "OK") return "plus: $v1"
+
+    var v2 = "FAIL"
+    obj -= { v2 = "OK" }
+    if (v2 != "OK") return "minus: $v2"
+
+    var v3 = "FAIL"
+    obj *= { v3 = "OK" }
+    if (v3 != "OK") return "times: $v3"
+
+    var v4 = "FAIL"
+    obj /= { v4 = "OK" }
+    if (v4 != "OK") return "div: $v4"
+
+    var v5 = "FAIL"
+    obj %= { v5 = "OK" }
+    if (v5 != "OK") return "mod: $v5"
+
+    return "OK"
+}
@@ -0,0 +1,61 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import org.jetbrains.annotations.NotNull;
+
+class JavaClass {
+    @NotNull JavaClass plus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass minus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass times(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass div(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass rem(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj += { v1 = "OK" }
+    if (v1 != "OK") return "plus: $v1"
+
+    var v2 = "FAIL"
+    obj -= { v2 = "OK" }
+    if (v2 != "OK") return "minus: $v2"
+
+    var v3 = "FAIL"
+    obj *= { v3 = "OK" }
+    if (v3 != "OK") return "times: $v3"
+
+    var v4 = "FAIL"
+    obj /= { v4 = "OK" }
+    if (v4 != "OK") return "div: $v4"
+
+    var v5 = "FAIL"
+    obj %= { v5 = "OK" }
+    if (v5 != "OK") return "mod: $v5"
+
+    return "OK"
+}
@@ -0,0 +1,68 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    JavaClass plus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass minus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass times(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass div(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass rem(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass rangeTo(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj + { v1 = "OK" }
+    if (v1 != "OK") return "plus: $v1"
+
+    var v2 = "FAIL"
+    obj - { v2 = "OK" }
+    if (v2 != "OK") return "minus: $v2"
+
+    var v3 = "FAIL"
+    obj * { v3 = "OK" }
+    if (v3 != "OK") return "times: $v3"
+
+    var v4 = "FAIL"
+    obj / { v4 = "OK" }
+    if (v4 != "OK") return "div: $v4"
+
+    var v5 = "FAIL"
+    obj % { v5 = "OK" }
+    if (v5 != "OK") return "mod: $v5"
+
+    var v6 = "FAIL"
+    obj .. { v6 = "OK" }
+    if (v6 != "OK") return "rangeTo: $v6"
+
+    return "OK"
+}
@@ -0,0 +1,35 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    int compareTo(Runnable i) {
+        i.run();
+        return 239;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj < { v1 = "OK" }
+    if (v1 != "OK") return "<: $v1"
+
+    var v2 = "FAIL"
+    obj > { v2 = "OK" }
+    if (v2 != "OK") return ">: $v2"
+
+    var v3 = "FAIL"
+    obj <= { v3 = "OK" }
+    if (v3 != "OK") return "<=: $v3"
+
+    var v4 = "FAIL"
+    obj >= { v4 = "OK" }
+    if (v4 != "OK") return ">=: $v4"
+
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    boolean contains(Runnable i) {
+        i.run();
+        return true;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    { v = "O" } in obj
+    { v += "K" } !in obj
+    return v
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    int get(Runnable i) {
+        i.run();
+        return 239;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    obj[{ v = "OK" }]
+    return v
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    void invoke(Runnable i) {
+        i.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    obj({ v = "O" })
+    obj { v += "K" }
+    return v
+}
@@ -0,0 +1,49 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// !LANGUAGE: -ProhibitOperatorMod
+// IGNORE_BACKEND_FIR: JVM_IR
+// MODULE: lib
+// FILE: Java.java
+
+import org.jetbrains.annotations.NotNull;
+
+class AugmentedAssignmentPure {
+    void modAssign(Runnable i) {
+        i.run();
+    }
+}
+
+class AugmentedAssignmentViaSimpleBinary {
+    @NotNull AugmentedAssignmentViaSimpleBinary rem(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+class Binary {
+    Binary rem(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val augAssignmentPure = AugmentedAssignmentPure()
+    var v1 = "FAIL"
+    augAssignmentPure %= { v1 = "OK" }
+    if (v1 != "OK") return "assignment pure: $v1"
+
+    var augmentedAssignmentViaSimpleBinary = AugmentedAssignmentViaSimpleBinary()
+    var v2 = "FAIL"
+    augmentedAssignmentViaSimpleBinary %= { v2 = "OK" }
+    if (v2 != "OK") return "assignment via simple binary: $v2"
+
+    val binary = Binary()
+    var v3 = "FAIL"
+    binary % { v3 = "OK" }
+    if (v3 != "OK") return "binary: $v3"
+
+    return "OK"
+}
@@ -0,0 +1,34 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    int get(Runnable i1, Runnable i2) {
+        i1.run();
+        i2.run();
+        return 239;
+    }
+
+    void set(Runnable i1, Runnable i2, Runnable value) {
+        i1.run();
+        i2.run();
+        value.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj[{ v1 = "O" }, { v1 += "K" }]
+    if (v1 != "OK") return "get: $v1"
+
+    var v2 = "FAIL"
+    obj[{ v2 = "" }, { v2 += "O" }] = { v2 += "K" }
+    if (v2 != "OK") return "set: $v2"
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    void invoke(Runnable p1, Runnable p2) {
+        p1.run();
+        p2.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    obj({ v = "O" }, { v += "K" })
+    return v
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    void set(Runnable i, Runnable value) {
+        i.run();
+        value.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    obj[{ v = "O" }] = { v += "K" }
+    return v
+}
@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass<T> {
+    protected void execute(T t, Runnable r) {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal class KotlinClass : JavaClass<String>() {
+    fun doIt(): String {
+        var result = ""
+        execute("") {
+            result = "OK"
+        }
+        return result
+    }
+}
+
+fun box(): String {
+    return KotlinClass().doIt()
+}
@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.*;
+
+class JavaClass {
+    public static String findMaxAndInvokeCallback(Comparator<String> comparator, String a, String b, Runnable afterRunnable) {
+        int compare = comparator.compare(a, b);
+        afterRunnable.run();
+        return compare > 0 ? a : b;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val max = JavaClass.findMaxAndInvokeCallback({ a, b -> a.length - b.length }, "foo", "kotlin", { v = "OK" })
+    if (max != "kotlin") return "Wrong max: $max"
+    return v
+}
@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static void run(Runnable r) {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    JavaClass.run { v = "OK" }
+    return v
+}
@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Supplier.java
+public interface Supplier<T> {
+    T get();
+}
+
+// FILE: Base.java
+public class Base {
+    private final Supplier<String> supplier;
+
+    public Base(Supplier<String> supplier) {
+        this.supplier = supplier;
+    }
+
+    public String get() {
+        return supplier.get();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: test.kt
+class Test : Base {
+    constructor(f: () -> String) : super(f)
+}
+
+fun box() = Test({ "OK" }).get()
@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    JavaClass(Runnable r) {
+        if (r != null) r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal class KotlinClass(): JavaClass(null) {
+}
+
+fun box(): String {
+    KotlinClass()
+    return "OK"
+}
@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    JavaClass(Runnable r) {
+        if (r != null) r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+var status: String = "fail"  // global property to avoid issues with accessing closure from local class (KT-4174)
+
+internal class KotlinClass(): JavaClass({status="OK"}) {
+}
+
+fun box(): String {
+    KotlinClass()
+    return status
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: WeirdComparator.java
+
+import java.util.*;
+
+class WeirdComparator<T> {
+    public T max(Comparator<T> comparator, T value1, T value2) {
+        return comparator.compare(value1, value2) > 0 ? value1 : value2;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val wc = WeirdComparator<String>()
+    val result = wc.max({ a, b -> a.length - b.length }, "java", "kotlin")
+    if (result != "kotlin") return "Wrong: $result"
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: WeirdComparator.java
+
+import java.util.*;
+
+class WeirdComparator {
+    public static <T> T max(Comparator<T> comparator, T value1, T value2) {
+        return comparator.compare(value1, value2) > 0 ? value1 : value2;
+    }
+
+    public static <T extends CharSequence> T max2(Comparator<T> comparator, T value1, T value2) {
+        return comparator.compare(value1, value2) > 0 ? value1 : value2;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val result = WeirdComparator.max<String>({ a, b -> a.length - b.length }, "java", "kotlin")
+    if (result != "kotlin") return "Wrong: $result"
+
+    val result2 = WeirdComparator.max2<String>({ a, b -> a.length - b.length }, "java", "kotlin")
+    if (result2 != "kotlin") return "Wrong: $result"
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: WeirdComparator.java
+
+import java.util.*;
+
+class WeirdComparator<T> {
+    public Inner createInner() {
+        return new Inner();
+    }
+
+    public class Inner {
+        public T max(Comparator<T> comparator, T value1, T value2) {
+            return comparator.compare(value1, value2) > 0 ? value1 : value2;
+        }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val wc = WeirdComparator<String>().createInner()!!
+    val result = wc.max({ a, b -> a.length - b.length }, "java", "kotlin")
+    if (result != "kotlin") return "Wrong: $result"
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Custom.java
+
+class Custom {
+    public interface Runnable {
+        void run2();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val f = { }
+    val class1 = Runnable(f).javaClass
+    val class2 = Custom.Runnable(f).javaClass
+
+    return if (class1 != class2) "OK" else "Same class: $class1"
+}
@@ -0,0 +1,44 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// SKIP_JDK6
+// MODULE: lib
+// FILE: Custom.java
+
+class Custom<K, V> {
+    private K k;
+
+    private V v;
+
+    public Custom(K k, V v) {
+        this.k = k;
+        this.v = v;
+    }
+
+    public interface MBiConsumer<T, U> {
+        void accept(T t, U u);
+    }
+
+    public void forEach(MBiConsumer<? super K, ? super V> action) {
+        action.accept(k, v);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.Arrays
+
+fun box(): String {
+    val instance = Custom<String, String>("O", "K")
+    var result = "fail"
+    instance.forEach { a, b ->
+        result = a + b
+    }
+
+    val superInterfaces = Arrays.toString((Class.forName("_1Kt\$box$1")).genericInterfaces)
+    if (superInterfaces != "[Custom\$MBiConsumer<java.lang.String, java.lang.String>]") {
+        return "fail: $superInterfaces"
+    }
+
+    return result
+}
@@ -0,0 +1,43 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// SKIP_JDK6
+// MODULE: lib
+// FILE: Custom.java
+
+class Custom<K, V> {
+    public interface MBiConsumer<T, U> {
+        void accept(T t, U u);
+    }
+
+    private K k;
+
+    private V v;
+
+    public Custom(K k, V v) {
+        this.k = k;
+        this.v = v;
+    }
+
+    public void forEach(MBiConsumer<? super K, ? super V> action) {
+        action.accept(k, v);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.Arrays
+
+fun box(): String {
+    val instance = Custom<String, String>("O", "K")
+    var result = "fail"
+    instance.forEach (Custom.MBiConsumer<String, String> { a, b ->
+        result = a + b
+    })
+
+    val superInterfaces = Arrays.toString((Class.forName("_1Kt\$box$1")).genericInterfaces)
+    if (superInterfaces != "[Custom\$MBiConsumer<java.lang.String, java.lang.String>]") {
+        return "fail: $superInterfaces"
+    }
+
+    return result
+}
@@ -0,0 +1,40 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Promise.java
+import org.jetbrains.annotations.NotNull;
+
+interface Consumer<T> {
+    void consume(T t);
+}
+
+public abstract class Promise<T> {
+    @NotNull
+    public abstract Promise<T> done(@NotNull Consumer<? super T> done);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+class User {
+    fun use(promise: Promise<*>): Promise<*> {
+        promise.done { }
+        return promise
+    }
+}
+
+fun box(): String {
+    var result = ""
+    User().use(
+            object : Promise<CharSequence>() {
+                override fun done(x: Consumer<in CharSequence?>): Promise<CharSequence> {
+                    result = x.javaClass.genericInterfaces[0].toString()
+                    return this
+                }
+            }
+    )
+
+    if (result != "Consumer<java.lang.Object>") return "fail: $result"
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Base.java
+
+interface Base<T> {
+    void call(T t);
+}
+
+// FILE: Derived.java
+
+interface Derived extends Base<String> {
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    Base<String>{}.call("")
+    Derived{}.call("")
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: ParamBase.java
+
+class ParamBase<T> {}
+
+// FILE: F.java
+
+interface F<T> extends FBase<ParamBase<? extends T>> {
+}
+
+// FILE: FBase.java
+
+interface FBase<T> {
+    void call(T t);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    F<ParamBase<Int>>({}).call(ParamBase())
+    return "OK"
+}
@@ -0,0 +1,17 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Base.java
+
+interface Interface {
+    String call(String t);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+val String.property: String
+    get() = this
+
+fun box(): String {
+    return Interface(String::property).call("OK")
+}
@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// SKIP_JDK6
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    interface Computable<T> {
+        T compute();
+    }
+
+    static <T> T compute(Computable<T> computable) {
+        return computable.compute();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.Arrays
+
+fun box(): String {
+    val r: JavaClass.Computable<String> = JavaClass.Computable { "OK" }
+    val supertypes = Arrays.toString(r.javaClass.getGenericInterfaces())
+    if (supertypes != "[JavaClass\$Computable<java.lang.String>]") return "Fail: $supertypes"
+    return JavaClass.compute(r)!!
+}
@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JFoo.java
+public interface JFoo<T> {
+    T foo(T x);
+}
+
+// FILE: J.java
+public class J {
+    public static void use(JFoo<String> jfoo) {
+        jfoo.foo(null);
+    }
+}
+
+
+// MODULE: main(lib)
+// FILE: test.kt
+fun test(a: Any) {
+    a as (String) -> String
+    J.use(a)
+}
+
+fun box(): String {
+    test({s: String? -> s})
+    return "OK"
+}