New J2K: Split old j2k and new j2k tests

nj2k/testData/newJ2k/overloads/Abstract.java

@@ -0,0 +1,7 @@
+abstract class A {
+    public abstract void foo(int p);
+
+    public void foo(){
+        foo(1);
+    }
+}

nj2k/testData/newJ2k/overloads/Abstract.kt

@@ -0,0 +1,7 @@
+internal abstract class A {
+    abstract fun foo(p: Int)
+
+    fun foo() {
+        foo(1)
+    }
+}

nj2k/testData/newJ2k/overloads/AccessorToDrop.java

@@ -0,0 +1,15 @@
+class A {
+    private int field = 0;
+
+    public int getField() {
+        return field;
+    }
+
+    public void setField(int field) {
+        this.field = field;
+    }
+
+    public void setField() {
+        setField(0);
+    }
+}

nj2k/testData/newJ2k/overloads/AccessorToDrop.kt

@@ -0,0 +1,7 @@
+internal class A {
+    var field = 0
+
+    fun setField() {
+        field = 0
+    }
+}

nj2k/testData/newJ2k/overloads/Annotations.java

@@ -0,0 +1,44 @@
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+class A {
+    @NotNull
+    Object foo(String s) {
+        System.out.println("s = " + s);
+        return "";
+    }
+
+    @NotNull
+    Object foo() {
+        return foo(null);
+    }
+
+    @Nullable
+    Object bar(String s) {
+        System.out.println("s = " + s);
+        return s == null ? "" : null;
+    }
+
+    @NotNull
+    Object bar() {
+        return bar(null);
+    }
+
+    public @Nullable Object bar1(String s) {
+        System.out.println("s = " + s);
+        return s == null ? "" : null;
+    }
+
+    public @NotNull Object bar1() {
+        return bar1(null);
+    }
+
+    @Deprecated
+    public void f() {
+        f(1);
+    }
+
+    public void f(int p) {
+        System.out.println("p = " + p);
+    }
+}

nj2k/testData/newJ2k/overloads/Annotations.kt

@@ -0,0 +1,34 @@
+internal class A {
+    @JvmOverloads
+    fun foo(s: String? = null): Any {
+        println("s = $s")
+        return ""
+    }
+
+    fun bar(s: String?): Any? {
+        println("s = $s")
+        return if (s == null) "" else null
+    }
+
+    fun bar(): Any {
+        return bar(null)!!
+    }
+
+    fun bar1(s: String?): Any? {
+        println("s = $s")
+        return if (s == null) "" else null
+    }
+
+    fun bar1(): Any {
+        return bar1(null)!!
+    }
+
+    @Deprecated("")
+    fun f() {
+        f(1)
+    }
+
+    fun f(p: Int) {
+        println("p = $p")
+    }
+}

nj2k/testData/newJ2k/overloads/Override.java

@@ -0,0 +1,46 @@
+interface I {
+    void foo(int i, char c, String s);
+    void bar();
+}
+
+class A implements I{
+    public void foo(int i, char c, String s) {
+        System.out.println("foo" + i + c + s);
+    }
+
+    public void foo(int i, char c) {
+        foo(i, c, "");
+    }
+
+    public void foo(int i) {
+        foo(i, 'a', "");
+    }
+
+    public void bar() {
+        bar(1);
+    }
+
+    public void bar(int i) {}
+
+    public void x() {
+        x(1);
+    }
+
+    public void x(int i) {}
+
+    public void y() {
+        y(1);
+    }
+
+    public void y(int i) {}
+}
+
+class B extends A {
+    public void x() {
+        super.x();
+    }
+
+    public void y(int i) {
+        super.y(i);
+    }
+}

nj2k/testData/newJ2k/overloads/Override.kt

@@ -0,0 +1,46 @@
+internal interface I {
+    fun foo(i: Int, c: Char, s: String)
+    fun bar()
+}
+
+internal open class A : I {
+    override fun foo(i: Int, c: Char, s: String) {
+        println("foo$i$c$s")
+    }
+
+    fun foo(i: Int, c: Char) {
+        foo(i, c, "")
+    }
+
+    fun foo(i: Int) {
+        foo(i, 'a', "")
+    }
+
+    override fun bar() {
+        bar(1)
+    }
+
+    fun bar(i: Int) {}
+
+    open fun x() {
+        x(1)
+    }
+
+    fun x(i: Int) {}
+
+    fun y() {
+        y(1)
+    }
+
+    open fun y(i: Int) {}
+}
+
+internal class B : A() {
+    override fun x() {
+        super.x()
+    }
+
+    override fun y(i: Int) {
+        super.y(i)
+    }
+}

nj2k/testData/newJ2k/overloads/Private.java

@@ -0,0 +1,10 @@
+class A {
+    private int bar(String s) {
+        System.out.println("s = " + s);
+        return 0;
+    }
+
+    private int bar() {
+        return bar(null);
+    }
+}

nj2k/testData/newJ2k/overloads/Private.kt

@@ -0,0 +1,6 @@
+internal class A {
+    private fun bar(s: String? = null): Int {
+        println("s = $s")
+        return 0
+    }
+}

nj2k/testData/newJ2k/overloads/Simple.java

@@ -0,0 +1,22 @@
+class A {
+    void foo(int i, char c, String s) {
+        System.out.println("foo" + i + c + s);
+    }
+
+    void foo(int i, char c) {
+        foo(i, c, "");
+    }
+
+    void foo(int i) {
+        foo(i, 'a', "");
+    }
+
+    int bar(String s) {
+        System.out.println("s = " + s);
+        return 0;
+    }
+
+    int bar() {
+        return bar(null);
+    }
+}

nj2k/testData/newJ2k/overloads/Simple.kt

@@ -0,0 +1,12 @@
+internal class A {
+    @JvmOverloads
+    fun foo(i: Int, c: Char = 'a', s: String = "") {
+        println("foo$i$c$s")
+    }
+
+    @JvmOverloads
+    fun bar(s: String? = null): Int {
+        println("s = $s")
+        return 0
+    }
+}

nj2k/testData/newJ2k/overloads/Synchronized.java

@@ -0,0 +1,12 @@
+class A {
+    public void foo(int p) {
+        System.out.println("p = [" + p + "]");
+    }
+
+    public synchronized void foo(){
+        foo(calcSomething());
+    }
+
+    // this method should be invoked under synchronized block!
+    private int calcSomething() { return 0; }
+}

nj2k/testData/newJ2k/overloads/Synchronized.kt

@@ -0,0 +1,15 @@
+internal class A {
+    fun foo(p: Int) {
+        println("p = [$p]")
+    }
+
+    @Synchronized
+    fun foo() {
+        foo(calcSomething())
+    }
+
+    // this method should be invoked under synchronized block!
+    private fun calcSomething(): Int {
+        return 0
+    }
+}