tests: Update external tests (1.1.2-dev-393)

backend.native/tests/external/codegen/box/operatorConventions/annotatedAssignment.kt

@@ -0,0 +1,13 @@
+@Target(AnnotationTarget.EXPRESSION)
+annotation class Annotation
+
+fun box(): String {
+    var v = 0
+    @Annotation v += 1 + 2
+    if (v != 3) return "fail1"
+
+    @Annotation v = 4
+    if (v != 4) return "fail2"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/assignmentOperations.kt

@@ -0,0 +1,36 @@
+class A() {
+  var x = 0
+}
+
+operator fun A.plusAssign(y: Int) { x += y }
+operator fun A.minusAssign(y: Int) { x -= y }
+operator fun A.timesAssign(y: Int) { x *= y }
+operator fun A.divAssign(y: Int) { x /= y }
+operator fun A.modAssign(y: Int) { x %= y }
+
+fun box(): String {
+  val original = A()
+  val a = original
+
+  a += 1
+  if (a !== original) return "Fail 1: $a !== $original"
+  if (a.x != 1) return "Fail 2: ${a.x} != 1"
+
+  a -= 2
+  if (a !== original) return "Fail 3: $a !== $original"
+  if (a.x != -1) return "Fail 4: ${a.x} != -1"
+
+  a *= -10
+  if (a !== original) return "Fail 5: $a !== $original"
+  if (a.x != 10) return "Fail 6: ${a.x} != 10"
+
+  a /= 3
+  if (a !== original) return "Fail 7: $a !== $original"
+  if (a.x != 3) return "Fail 8: ${a.x} != 3"
+
+  a %= 2
+  if (a !== original) return "Fail 9: $a !== $original"
+  if (a.x != 1) return "Fail 10: ${a.x} != 1"
+
+  return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/augmentedAssignmentInInitializer.kt

@@ -0,0 +1,45 @@
+abstract class A {
+    val b = B("O")
+
+    open val c: B
+
+    val d: B
+        get() = field
+
+    var e: String
+        get() = field
+
+    init {
+        c = B("O")
+        d = B("O")
+        e = "O"
+
+        b += ","
+        c += "."
+        d += ";"
+        e += "|"
+    }
+}
+
+class B(var value: String) {
+    operator fun plusAssign(o: String) {
+        value += o
+    }
+}
+
+class C : A() {
+    init {
+        b += "K"
+        c += "K"
+        d += "K"
+        e += "K"
+    }
+}
+
+fun box(): String {
+    val c = C()
+    val result = "${c.b.value} ${c.c.value} ${c.d.value} ${c.e}"
+    if (result != "O,K O.K O;K O|K") return "fail: $result"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/augmentedAssignmentWithArrayLHS.kt

@@ -0,0 +1,33 @@
+var log = ""
+
+fun foo(): Int {
+    log += "foo;"
+    return 1
+}
+fun bar(): Int {
+    log += "bar;"
+    return 42
+}
+
+data class A(val x: Int) {
+    operator fun plus(other: A) = A(x + other.x)
+}
+
+fun box(): String {
+    val array = arrayOf(0, 1)
+    array[foo()] += bar()
+
+    if (array[0] != 0) return "fail1a: ${array[0]}"
+    if (array[1] != 43) return "fail1b: ${array[0]}"
+
+    log += "!;"
+
+    val objArray = arrayOf(A(0), A(1))
+    objArray[foo()] += A(bar())
+    if (objArray[0] != A(0)) return "fail2a: ${array[0]}"
+    if (objArray[1] != A(43)) return "fail2b: ${array[0]}"
+
+    if (log != "foo;bar;!;foo;bar;") return "fail3: $log"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/compareTo/boolean.kt

@@ -0,0 +1,13 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+fun checkLess(x: Boolean, y: Boolean) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(false, true)

backend.native/tests/external/codegen/box/operatorConventions/compareTo/comparable.kt

@@ -0,0 +1,16 @@
+interface A : Comparable<A>
+
+class B(val x: Int) : A {
+    override fun compareTo(other: A) = x.compareTo((other as B).x)
+}
+
+fun checkLess(x: A, y: A) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(B(0), B(1))

backend.native/tests/external/codegen/box/operatorConventions/compareTo/doubleInt.kt

@@ -0,0 +1,10 @@
+fun checkLess(x: Double, y: Int) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(0.5, 1)

backend.native/tests/external/codegen/box/operatorConventions/compareTo/doubleLong.kt

@@ -0,0 +1,10 @@
+fun checkLess(x: Double, y: Long) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(0.5, 1.toLong())

backend.native/tests/external/codegen/box/operatorConventions/compareTo/extensionArray.kt

@@ -0,0 +1,16 @@
+fun checkLess(x: Array<Int>, y: Array<Int>) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+operator fun Array<Int>.compareTo(other: Array<Int>) = size - other.size
+
+fun box(): String {
+    val a = arrayOfNulls<Int>(0) as Array<Int>
+    val b = arrayOfNulls<Int>(1) as Array<Int>
+    return checkLess(a, b)
+}

backend.native/tests/external/codegen/box/operatorConventions/compareTo/extensionObject.kt

@@ -0,0 +1,14 @@
+class A(val x: Int)
+
+operator fun A.compareTo(other: A) = x.compareTo(other.x)
+
+fun checkLess(x: A, y: A) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(A(0), A(1))

backend.native/tests/external/codegen/box/operatorConventions/compareTo/intDouble.kt

@@ -0,0 +1,10 @@
+fun checkLess(x: Int, y: Double) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(0, 0.5)

backend.native/tests/external/codegen/box/operatorConventions/compareTo/intLong.kt

@@ -0,0 +1,10 @@
+fun checkLess(x: Int, y: Long) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(0, 123456789123.toLong())

backend.native/tests/external/codegen/box/operatorConventions/compareTo/longDouble.kt

@@ -0,0 +1,10 @@
+fun checkLess(x: Long, y: Double) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(0.toLong(), 0.5)

backend.native/tests/external/codegen/box/operatorConventions/compareTo/longInt.kt

@@ -0,0 +1,10 @@
+fun checkLess(x: Long, y: Int) = when {
+    x >= y    -> "Fail $x >= $y"
+    !(x < y)  -> "Fail !($x < $y)"
+    !(x <= y) -> "Fail !($x <= $y)"
+    x > y     -> "Fail $x > $y"
+    x.compareTo(y) >= 0 -> "Fail $x.compareTo($y) >= 0"
+    else -> "OK"
+}
+
+fun box() = checkLess(-123456789123.toLong(), 0)

backend.native/tests/external/codegen/box/operatorConventions/incDecOnObject.kt

@@ -0,0 +1,41 @@
+class X(var value: Long)
+
+operator fun X.inc(): X {
+    this.value++
+    return this
+}
+
+operator fun X.dec(): X {
+    this.value--
+    return this
+}
+
+class Z {
+
+    public var counter: Int = 0;
+
+    public var prop: X = X(0)
+        get()  {
+            counter++; return field
+        }
+        set(a: X) {
+            counter++
+            field = a;
+        }
+}
+
+fun box(): String {
+    var z = Z()
+    z.prop++
+
+    if (z.counter != 2) return "fail in postfix increment: ${z.counter} != 2"
+    if (z.prop.value != 1.toLong()) return "fail in postfix increment: ${z.prop.value} != 1"
+
+    z = Z()
+    z.prop--
+
+    if (z.counter != 2) return "fail in postfix decrement: ${z.counter} != 2"
+    if (z.prop.value != -1.toLong()) return "fail in postfix decrement: ${z.prop.value} != -1"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/infixFunctionOverBuiltinMember.kt

@@ -0,0 +1,18 @@
+infix fun Int.rem(other: Int) = 10
+infix operator fun Int.minus(other: Int): Int = 20
+
+fun box(): String {
+    val a = 5 rem 2
+    if (a != 10) return "fail 1"
+
+    val b = 5 minus 3
+    if (b != 20) return "fail 2"
+
+    val a1 = 5.rem(2)
+    if (a1 != 1) return "fail 3"
+
+    val b2 = 5.minus(3)
+    if (b2 != 2) return "fail 4"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/kt14201.kt

@@ -0,0 +1,15 @@
+interface Intf {
+    val aValue: String
+}
+
+class ClassB {
+    val x = { "OK" }
+
+    val value: Intf = object : Intf {
+        override val aValue = x()
+    }
+}
+
+fun box() : String {
+    return ClassB().value.aValue
+}

backend.native/tests/external/codegen/box/operatorConventions/kt14201_2.kt

@@ -0,0 +1,27 @@
+class A {
+    val z: String = "OK"
+}
+
+class B {
+    operator fun A.invoke(): String = z
+}
+
+class ClassB {
+    val x = A()
+
+    fun B.test(): String {
+        val value = object {
+            val z = x()
+        }
+        return value.z
+    }
+
+    fun call(): String {
+        return B().test()
+    }
+
+}
+
+fun box(): String {
+    return ClassB().call()
+}

backend.native/tests/external/codegen/box/operatorConventions/kt4152.kt

@@ -0,0 +1,29 @@
+public var inc: Int = 0;
+
+public var propInc: Int = 0
+    get() {inc++; return field}
+    set(a: Int) {
+        inc++
+        field = a
+    }
+
+public var dec: Int = 0;
+
+public var propDec: Int = 0
+    get() { dec--; return field}
+    set(a: Int) {
+        dec--
+        field = a
+    }
+
+fun box(): String {
+    propInc++
+    if (inc != 2) return "fail in postfix increment: ${inc} != 2"
+    if (propInc != 1) return "fail in postfix increment: ${propInc} != 1"
+
+    propDec--
+    if (dec != -2) return "fail in postfix decrement: ${dec} != -2"
+    if (propDec != -1) return "fail in postfix decrement: ${propDec} != -1"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/kt4987.kt

@@ -0,0 +1,6 @@
+fun box(): String {
+    operator fun Int?.inc() = (this ?: 0) + 1
+    var counter: Int? = null
+    counter++
+    return if (counter == 1) "OK" else "fail: $counter"
+}

backend.native/tests/external/codegen/box/operatorConventions/nestedMaps.kt

@@ -0,0 +1,13 @@
+object Map1 {
+    operator fun get(i: Int, j: Int) = Map2
+}
+
+object Map2 {
+    operator fun get(i: Int, j: Int) = 0
+    operator fun set(i: Int, j: Int, newValue: Int) {}
+}
+
+fun box(): String {
+    Map1[0, 0][0, 0]++
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/operatorSetLambda.kt

@@ -0,0 +1,16 @@
+// See KT-14999
+
+object Obj {
+    var key = ""
+    var value = ""
+
+    operator fun set(k: String, v: ((String) -> Unit) -> Unit) {
+        key += k
+        v { value += it }
+    }
+}
+
+fun box(): String {
+    Obj["O"] = label@{ it("K") }
+    return Obj.key + Obj.value
+}

backend.native/tests/external/codegen/box/operatorConventions/overloadedSet.kt

@@ -0,0 +1,11 @@
+object A {
+    operator fun get(i: Int) = 1
+    operator fun set(i: Int, j: Int) {}
+    operator fun set(i: Int, x: Any) { throw Exception() }
+}
+
+fun box(): String {
+    A[0]++
+    A[0] += 1
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/percentAsModOnBigIntegerWithoutRem.kt

@@ -0,0 +1,11 @@
+// TARGET_BACKEND: JVM
+
+// LANGUAGE_VERSION: 1.0
+// FULL_JDK
+
+import java.math.BigInteger
+
+fun box(): String {
+    val m = BigInteger.valueOf(-2) % BigInteger.valueOf(3)
+    return if (m != BigInteger.valueOf(1)) "Fail: BigInteger(-2) mod BigInteger(3) == $m" else "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/plusExplicit.kt

@@ -0,0 +1,29 @@
+// WITH_RUNTIME
+
+fun bar1(): String {
+    val l: List<String> = listOf("O")
+    val s = l[0].plus("K")
+    return s
+}
+
+fun bar2(): String {
+    val l: List<String?> = listOf("O")
+    val s = l[0]?.plus("K")
+    return s!!
+}
+
+fun bar3(): String {
+    val l: List<String> = listOf("O")
+    with(l[0]) {
+        return plus("K")
+    }
+    return "fail"
+}
+
+fun box(): String {
+    if (bar1() != "OK") return "fail 1"
+    if (bar2() != "OK") return "fail 2"
+    if (bar3() != "OK") return "fail 3"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/remAssignmentOperation.kt

@@ -0,0 +1,17 @@
+class A() {
+    var x = 5
+}
+
+operator fun A.modAssign(y: Int) { throw RuntimeException("mod has been called instead of rem") }
+operator fun A.remAssign(y: Int) { x %= y + 1 }
+
+fun box(): String {
+    val original = A()
+    val a = original
+
+    a %= 2
+    if (a !== original) return "Fail 1: $a !== $original"
+    if (a.x != 2) return "Fail 2: ${a.x} != 2"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/operatorConventions/remOverModOperation.kt

@@ -0,0 +1,18 @@
+class A() {
+    var x = 5
+
+    operator fun mod(y: Int) { throw RuntimeException("mod has been called instead of rem") }
+    operator fun rem(y: Int) { x -= y }
+}
+
+fun box(): String {
+    val a = A()
+
+    a % 5
+
+    if (a.x != 0) {
+        return "Fail: a.x(${a.x}) != 0"
+    }
+
+    return "OK"
+}