[Tests] Migrate backend-independent tests from native to compiler/testData.

^KT-65979

compiler/testData/codegen/box/arithmetic/basic_charConversions.kt

@@ -0,0 +1,13 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals(97.0, 'a'.toDouble())
+    assertEquals(-1, Char.MAX_VALUE.toShort())
+    assertEquals(32768, Short.MIN_VALUE.toChar().toInt())
+    assertEquals(-1, Char.MAX_VALUE.toByte())
+    assertEquals(65408, Byte.MIN_VALUE.toChar().toInt())
+    assertEquals(0, Float.MIN_VALUE.toChar().toInt())
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_charCornerCases.kt

@@ -0,0 +1,21 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+private fun charCornersMinus(): Int {
+    val a: Char = 0xFFFF.toChar()
+    val b: Char = 0.toChar()
+    return a - b
+}
+
+private fun charCornersComparison(): Boolean {
+    val a = 0xFFFF.toChar()
+    val b = 0.toChar()
+    return a < b
+}
+
+fun box(): String {
+    assertEquals(65535, charCornersMinus())
+    assertFalse(charCornersComparison())
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_compareIntToFloat.kt

@@ -0,0 +1,9 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals(1, 0.compareTo(-0.0f))
+    assertEquals(0, 0.compareTo(+0.0f))
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_doubleBasic.kt

@@ -0,0 +1,15 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals(1, 0f.compareTo(-0f))
+    assertEquals(1, 0.0.compareTo(-0.0))
+
+    assertEquals(1.0, Double.fromBits(1.0.toBits()))
+    assertEquals(1.0f, Float.fromBits(1.0f.toBits()))
+
+    assertEquals(Double.NaN, Double.fromBits((0 / 0.0).toBits()))
+    assertEquals(Float.NaN, Float.fromBits((0 / 0f).toBits()))
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_integralToFloat.kt

@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// KT-66079
+// IGNORE_BACKEND: JS_IR, JS_IR_ES6
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals(9.223372E18f, Long.MAX_VALUE.toFloat())
+    assertEquals(-9.223372E18f, Long.MIN_VALUE.toFloat())
+
+    assertEquals(-2.147483648E9, Int.MIN_VALUE.toDouble())
+    assertEquals(2.147483647E9, Int.MAX_VALUE.toDouble())
+
+    assertEquals(2147483647, Double.MAX_VALUE.toInt())
+    assertEquals(0, Float.MIN_VALUE.toLong())
+
+    assertEquals(9223372036854775807, Float.MAX_VALUE.toLong())
+    assertEquals(0, Double.MIN_VALUE.toInt())
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_kt37412.kt

@@ -0,0 +1,9 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+fun box(): String {
+    val two = 2.0
+    assertEquals(2, two.toInt())
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_selfComparison.kt

@@ -0,0 +1,14 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+// Check that compiler doesn't optimize it to `true`
+fun selfCmp1(x: Int) = x + 1 > x
+
+fun selfCmp2(x: Int) = x - 1 < x
+
+fun box(): String {
+    assertFalse(selfCmp1(Int.MAX_VALUE))
+    assertFalse(selfCmp2(Int.MIN_VALUE))
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_shifts.kt

@@ -0,0 +1,12 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals(-2147483648, 1 shl -1)
+    assertEquals(0, 1 shr -1)
+    assertEquals(1, 1 shl 32)
+    assertEquals(1073741823, -1 ushr 2)
+    assertEquals(-1, -1 shr 2)
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/basic_uintTests.kt

@@ -0,0 +1,8 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals(UInt.MAX_VALUE, UInt.MIN_VALUE - 1u)
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/division.kt

@@ -0,0 +1,15 @@
+// WITH_STDLIB
+// KT-66080
+// IGNORE_BACKEND: JS_IR, JS_IR_ES6
+// KT-66081
+// IGNORE_BACKEND: WASM
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith(ArithmeticException::class, { 5 / 0 })
+    assertFailsWith(ArithmeticException::class, { 5 % 0 })
+    assertEquals(1, 5 / try { 0 / 0; 1 } catch (e: ArithmeticException) { 5 })
+    assertEquals(Double.NaN, 0.0 / 0.0)
+
+    return "OK"
+}

compiler/testData/codegen/box/arithmetic/github1856.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+import kotlin.test.*
+
+object RGBA {
+    fun packFast(r: Int, g: Int, b: Int, a: Int) = (r shl 0) or (g shl 8) or (b shl 16) or (a shl 24)
+
+    fun getFastR(v: Int): Int = (v ushr 0) and 0xFF
+    fun getFastG(v: Int): Int = (v ushr 8) and 0xFF
+    fun getFastB(v: Int): Int = (v ushr 16) and 0xFF
+    fun getFastA(v: Int): Int = (v ushr 24) and 0xFF
+
+    fun premultiplyFastInt(v: Int): Int {
+        val A = getFastA(v) + 1
+        val RB = (((v and 0x00FF00FF) * A) ushr 8) and 0x00FF00FF
+        val G = (((v and 0x0000FF00) * A) ushr 8) and 0x0000FF00
+        return (v and 0x00FFFFFF.inv()) or RB or G
+    }
+}
+
+fun box(): String {
+    val source = listOf(0xFFFFFFFF.toInt(), 0xFFFFFF77.toInt(), 0x777777FF.toInt(), 0x77777777.toInt())
+    val expect = listOf(-1, -137, 2000107383, 2000107319)
+    assertEquals(expect, source.map { RGBA.premultiplyFastInt(it) })
+
+    return "OK"
+}