JS backend: tests for Long type support

js/js.tests/test/org/jetbrains/k2js/test/semantics/NumberTest.java

@@ -85,4 +85,28 @@ public final class NumberTest extends SingleFileTranslationTest {
     public void testConversionsWithTruncation() throws Exception {
         checkFooBoxIsOk();
     }
+
+    public void testLongEqualsIntrinsic() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testLongArray() throws Exception {
+       checkFooBoxIsOk();
+    }
+
+    public void testLongCompareToIntrinsic() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testLongBinaryOperations() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testLongUnaryOperations() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testLongBitOperations() throws Exception {
+        checkFooBoxIsOk();
+    }
 }

js/js.translator/testData/expression/for/cases/forIteratesOverArray.kt

@@ -24,5 +24,11 @@ fun box(): Boolean {
         try { s += "A${i}:"} finally {}
     assertEquals("A0:A1:A2:", s)
 
+    var sLong = 0L
+    var aLong = longArray(1,2,3,4,5,6,7,8,9,10)
+    for(i in aLong)
+        sLong += i
+    assertEquals(55L, sLong)
+
     return true
 }

js/js.translator/testData/expression/for/cases/forIteratesOverLiteralRange.kt

@@ -48,5 +48,15 @@ fun box(): String {
     }
     assertEquals("AB", global)
 
+    var sLong = 0L
+    for(i in 0L..10L)
+        sLong += i
+    assertEquals(55L, sLong)
+
+    var sDouble = 0.0
+    for(i in 0L..10.0)
+        sDouble += i
+    assertEquals(55.0, sDouble)
+
     return "OK"
 }

js/js.translator/testData/expression/for/cases/forIteratesOverNonLiteralRange.kt

@@ -12,5 +12,17 @@ fun box(): String {
         n++
     assertEquals(4, n)
 
+    var sLong = 0L
+    var rLong = 0L..10L
+    for(i in rLong)
+        sLong += i
+    assertEquals(55L, sLong)
+
+    var sDouble = 0.0
+    var rDouble = 0L..10.0
+    for(i in rDouble)
+        sDouble += i
+    assertEquals(55.0, sDouble)
+
     return "OK"
 }

js/js.translator/testData/number/cases/conversionsWithTruncation.kt

@@ -8,6 +8,9 @@ fun box(): String {
     assertEquals(65, 321.0f.toByte())
     assertEquals(-56, 200.0f.toByte())
 
+    assertEquals(65, 321L.toByte())
+    assertEquals(-56, 200L.toByte())
+
     assertEquals(65, 321.toByte())
     assertEquals(-56, 200.toByte())
 
@@ -16,6 +19,7 @@ fun box(): String {
 
     assertEquals(-1, 65535.0.toShort())
     assertEquals(-1, 65535.0f.toShort())
+    assertEquals(-1, 65535L.toShort())
     assertEquals(-1, 65535.toShort())
 
     assertEquals(65535, 65535.2.toInt())
@@ -23,5 +27,19 @@ fun box(): String {
     assertEquals(-12, -12.4.toShort())
     assertEquals(-12, -12.4.toByte())
 
+    val longX: Long = 9223372034707292481L
+    assertEquals("9223372034707292481", longX.toString())
+    val doubleX: Double = safeParseDouble("9223372034707292481")!!
+    assertEquals(doubleX, longX.toDouble())
+    assertEquals(doubleX, longX.toFloat())
+
+    assertEquals(-2147483327, longX.toInt())
+    assertEquals(321, longX.toShort())
+    assertEquals(65, longX.toByte())
+
+    val intX: Int = longX.toInt()
+    assertEquals(321, intX.toShort())
+    assertEquals(65, intX.toByte())
+
     return "OK"
 }

js/js.translator/testData/number/cases/conversionsWithoutTruncation.kt

@@ -3,6 +3,7 @@ package foo
 fun testForNumber(numberX: Number) {
     assertEquals(true, 65.0 == numberX.toDouble())
     assertEquals(true, 65.0f == numberX.toFloat())
+    assertEquals(true, 65L == numberX.toLong())
     assertEquals(true, 65 == numberX.toInt())
     assertEquals(true, (65: Short) == numberX.toShort())
     assertEquals(true, (65: Byte) == numberX.toByte())
@@ -12,6 +13,7 @@ fun box(): String {
 
     testForNumber(65.0)
     testForNumber(65.0f)
+    testForNumber(65L)
     testForNumber(65)
     testForNumber(65: Short)
     testForNumber(65: Byte)
@@ -19,6 +21,7 @@ fun box(): String {
     var doubleX: Double = 65.0
     assertEquals(true, 65.0 == doubleX.toDouble())
     assertEquals(true, 65.0f == doubleX.toFloat())
+    assertEquals(true, 65L == doubleX.toLong())
     assertEquals(true, 65 == doubleX.toInt())
     assertEquals(true, (65: Short) == doubleX.toShort())
     assertEquals(true, (65: Byte) == doubleX.toByte())
@@ -26,13 +29,23 @@ fun box(): String {
     var floatX: Float = 65.0f
     assertEquals(true, 65.0 == floatX.toDouble())
     assertEquals(true, 65.0f == floatX.toFloat())
+    assertEquals(true, 65L == floatX.toLong())
     assertEquals(true, 65 == floatX.toInt())
     assertEquals(true, (65: Short) == floatX.toShort())
     assertEquals(true, (65: Byte) == floatX.toByte())
 
+    val longX: Long = 65L
+    assertEquals(true, 65.0 == longX.toDouble())
+    assertEquals(true, 65.0f == longX.toFloat())
+    assertEquals(true, 65L == longX.toLong())
+    assertEquals(true, 65 == longX.toInt())
+    assertEquals(true, (65: Short) == longX.toShort())
+    assertEquals(true, (65: Byte) == longX.toByte())
+
     val intX: Int = 65
     assertEquals(true, 65.0 == intX.toDouble())
     assertEquals(true, 65.0f == intX.toFloat())
+    assertEquals(true, 65L == intX.toLong())
     assertEquals(true, 65 == intX.toInt())
     assertEquals(true, (65: Short) == intX.toShort())
     assertEquals(true, (65: Byte) == intX.toByte())
@@ -40,6 +53,7 @@ fun box(): String {
     val shortX: Short = 65: Short
     assertEquals(true, 65.0 == shortX.toDouble())
     assertEquals(true, 65.0f == shortX.toFloat())
+    assertEquals(true, 65L == shortX.toLong())
     assertEquals(true, 65 == shortX.toInt())
     assertEquals(true, (65: Short) == shortX.toShort())
     assertEquals(true, (65: Byte) == shortX.toByte())
@@ -47,6 +61,7 @@ fun box(): String {
     val byteX: Byte = 65: Byte
     assertEquals(true, 65.0 == byteX.toDouble())
     assertEquals(true, 65.0f == byteX.toFloat())
+    assertEquals(true, 65L == byteX.toLong())
     assertEquals(true, 65 == byteX.toInt())
     assertEquals(true, (65: Short) == byteX.toShort())
     assertEquals(true, (65: Byte) == byteX.toByte())

js/js.translator/testData/number/cases/longArray.kt

@@ -0,0 +1,22 @@
+package foo
+
+fun box(): String {
+
+    val arr = LongArray(2)
+
+    val expected: Long = 0
+    assertEquals(arr.size, 2)
+    assertEquals(expected, arr[0])
+    assertEquals(expected, arr[1])
+
+    arr[0] = 2432902008176640000L
+    assertEquals(2432902008176640000L, arr[0])
+
+    val arr1 = longArray(1,2,3, 2432902008176640000L)
+    assertEquals(1L, arr1[0])
+    assertEquals(2L, arr1[1])
+    assertEquals(3L, arr1[2])
+    assertEquals(2432902008176640000L, arr1[3])
+
+    return "OK"
+}

js/js.translator/testData/number/cases/longBinaryOperations.kt

@@ -0,0 +1,53 @@
+package foo
+
+fun fact(n: Int): Long = if (n == 1) 1L else n * fact(n - 1)
+
+fun fib(n: Int): Long {
+    var a = 0L
+    var b = 1L
+    for (i in 2..n) {
+        var tmp = a
+        a = b
+        b = b + tmp
+    }
+    return b
+}
+
+fun box(): String {
+
+    assertEquals(30.0, 10L + 20.0)
+    assertEquals(30.0f, 10L + 20.0f)
+    assertEquals(30L, 10L + 20L)
+    assertEquals(30L, 10L + 20)
+    assertEquals(30L, 10L + (20: Short))
+    assertEquals(30L, 10L + (20: Byte))
+
+    assertEquals(30.0, 20.0 + 10L)
+    assertEquals(30.0f, 20.0f + 10L)
+    assertEquals(20L, 10 + 10L)
+    assertEquals(20L, (10: Short) + 10L)
+    assertEquals(20L, (10: Byte) + 10L)
+
+    assertEquals(20L, 30 - 10L)
+
+    assertEquals(100L, 10 * 10L)
+    assertEquals(100.0, 10.0 * 10L)
+
+    assertEquals(100L, 10L * 10)
+    assertEquals(100.0, 10L * 10.0)
+
+    assertEquals(100L, 1000L / 10)
+    assertEquals(100L, 1000 / 10L)
+
+    assertEquals(100.0, 1000L / 10.0)
+    assertEquals(100.0, 1000.0 / 10L)
+
+    assertEquals(2L, 100L % 7)
+    assertEquals(2L, 100 % 7L)
+
+    assertEquals(2432902008176640000L, fact(20))
+    assertEquals(12586269025L, fib(50))
+    assertEquals(7540113804746346429L, fib(92))
+
+    return "OK"
+}

js/js.translator/testData/number/cases/longBitOperations.kt

@@ -0,0 +1,23 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(65536L, 1L shl 16)
+    assertEquals(1L, 65536L shr 16)
+
+    assertEquals(-1L, -1L shr 48)
+    assertEquals(65535L, -1L ushr 48)
+
+    assertEquals(-1L, 0L.inv())
+
+    assertEquals(0b1000L, 0b1100L and 0b1010L)
+    assertEquals(0b1110L, 0b1100L or 0b1010L)
+    assertEquals(0b0110L, 0b1100L xor 0b1010L)
+
+    assertEquals(0xab88ac0021L, 0xabcdef0123L and 0xefaabcdef1L)
+    assertEquals(0xefefffdff3L, 0xabcdef0123L or 0xefaabcdef1L)
+    assertEquals(0x446753dfd2L, 0xabcdef0123L xor 0xefaabcdef1L)
+    assertEquals(-737894400292, 0xabcdef0123L.inv())
+
+    return "OK"
+}

js/js.translator/testData/number/cases/longCompareToIntrinsic.kt

@@ -0,0 +1,40 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(true, 10.0 < 20L, "Double.compareTo(Long)")
+    assertEquals(true, 10.0 < 7540113804746346429L, "Double.compareTo(Long)")
+
+    assertEquals(true, 10.0f < 20L, "Float.compareTo(Long)")
+    assertEquals(true, 10.0f < 7540113804746346429L, "Float.compareTo(Long)")
+
+    assertEquals(true, 10L < 20L, "Long.compareTo(Long)")
+    assertEquals(true, 10 < 20L, "Int.compareTo(Long)")
+    assertEquals(true, 10 < 7540113804746346429L, "Int.compareTo(Long)")
+
+    assertEquals(true, (10: Short) < 20L, "Short.compareTo(Long)")
+    assertEquals(true, (10: Short) < 7540113804746346429L, "Short.compareTo(Long)")
+    assertEquals(true, (10: Byte) < 20L, "Byte.compareTo(Long)")
+    assertEquals(true, (10: Byte) < 7540113804746346429L, "Byte.compareTo(Long)")
+
+    assertEquals(true, 10L < 20.0, "Long.compareTo(Double)")
+    assertEquals(false, 7540113804746346429L < 20.0, "Long.compareTo(Double)")
+
+    assertEquals(true, 10L < 20.0f, "Long.compareTo(Float)")
+    assertEquals(true, 7540113804746346429L > 20.0f, "Long.compareTo(Float)")
+    assertEquals(false, 7540113804746346429L < 20.0f, "Long.compareTo(Float)")
+
+    assertEquals(true, 10L < 20, "Long.compareTo(Int)")
+    assertEquals(true, 7540113804746346429L > 20, "Long.compareTo(Int)")
+    assertEquals(false, 7540113804746346429L < 20, "Long.compareTo(Int)")
+
+    assertEquals(true, 10L < (20: Short), "Long.compareTo(Short)")
+    assertEquals(true, 7540113804746346429L > (20: Short), "Long.compareTo(Short)")
+    assertEquals(false, 7540113804746346429L < (20: Short), "Long.compareTo(Short)")
+
+    assertEquals(true, 10L < (20: Byte), "Long.compareTo(Byte)")
+    assertEquals(true, 7540113804746346429L > (20: Byte), "Long.compareTo(Byte)")
+    assertEquals(false, 7540113804746346429L < (20: Byte), "Long.compareTo(Byte)")
+
+    return "OK"
+}

js/js.translator/testData/number/cases/longEqualsIntrinsic.kt

@@ -0,0 +1,31 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(true, 10L == 10L, "Long == Long")
+    assertEquals(true, 10L != 11L, "Long != Long")
+
+    val x1: Long? = 10L
+    val x2: Long? = 10L
+    assertEquals(false, x1 == null, "Long? == null")
+    assertEquals(false, null == x1, "null == Long?")
+    assertEquals(true, x1 == 10L, "Long? == Long")
+    assertEquals(true, 10L == x1, "Long? == Long")
+    assertEquals(true, x1 == x2, "Long? == Long?")
+
+    val number1: Number = 10L
+    val number2: Number = 10L
+    assertEquals(true, number1 == number2, "Number == Number")
+    assertEquals(true, number1 == 10L, "Number == Long")
+    assertEquals(true, number1 != 11L, "Number != Long")
+    assertEquals(true, 10L == number1, "Long == Number")
+    assertEquals(true, 11L != number1, "Long != Number")
+
+    val y1: Any = 10L
+    var y2: Any = 10
+    assertEquals(true, y1 == 10L, "Any == Long")
+    assertEquals(true, 10L == y1, "Long == Any 1")
+    assertEquals(false, 10L == y2, "Long == Any 2")
+
+    return "OK"
+}

js/js.translator/testData/number/cases/longUnaryOperations.kt

@@ -0,0 +1,31 @@
+package foo
+
+fun box(): String {
+
+    var x: Long = 2L
+    x++
+    assertEquals(3L, x)
+    ++x
+    assertEquals(4L, x)
+
+    var y = x++
+    assertEquals(4L, y)
+    assertEquals(5L, x)
+
+    y = ++x
+    assertEquals(6L, y)
+    assertEquals(6L, x)
+
+    x--
+    assertEquals(5L, x)
+    --x
+    assertEquals(4L, x)
+
+    y = +x
+    assertEquals(4L, y)
+
+    y = -x
+    assertEquals(-4L, y)
+
+    return "OK"
+}

js/js.translator/testData/number/cases/numberCompareTo.kt

@@ -12,24 +12,30 @@ fun box(): String {
     assertEquals(-1, 1.compareTo(2))
     assertEquals(-1, (1: Comparable<Int>).compareTo(2))
 
-    assertEquals(-1, 1 compareTo 2)
+    assertEquals(-1, 1 compareTo 2L)
+    assertEquals(-1, 1 compareTo 2L)
+    assertEquals(-1, 1 compareTo 7540113804746346429L)
     assertEquals(-1, 1 compareTo (2:Short))
     assertEquals(-1, 1 compareTo (2:Byte))
     assertEquals(-1, 1 compareTo 2.0)
     assertEquals(-1, 1 compareTo 2.0f)
 
+    assertEquals(1, 10 compareTo 2L)
     assertEquals(1, 10 compareTo 2)
     assertEquals(1, 10 compareTo (2:Short))
     assertEquals(1, 10 compareTo (2:Byte))
     assertEquals(1, 10 compareTo 2.0)
     assertEquals(1, 10 compareTo 2.0f)
 
+    assertEquals(0, 2 compareTo 2L)
     assertEquals(0, 2 compareTo 2)
     assertEquals(0, 2 compareTo (2:Short))
     assertEquals(0, 2 compareTo (2:Byte))
     assertEquals(0, 2 compareTo 2.0)
     assertEquals(0, 2 compareTo 2.0f)
 
+    assertEquals(-1, (1: Short) compareTo 2L)
+    assertEquals(-1, (1: Short) compareTo 7540113804746346429L)
     assertEquals(-1, (1: Short) compareTo 2)
     assertEquals(-1, (1: Short) compareTo (2:Short))
     assertEquals(-1, ((1: Short): Comparable<Short>) compareTo (2:Short))
@@ -37,6 +43,8 @@ fun box(): String {
     assertEquals(-1, (1: Short) compareTo 2.0)
     assertEquals(-1, (1: Short) compareTo 2.0f)
 
+    assertEquals(1, (10: Byte) compareTo 2L)
+    assertEquals(-1, (10: Byte) compareTo 7540113804746346429L)
     assertEquals(1, (10: Byte) compareTo 2)
     assertEquals(1, (10: Byte) compareTo (2:Short))
     assertEquals(1, (10: Byte) compareTo (2:Byte))
@@ -44,6 +52,8 @@ fun box(): String {
     assertEquals(1, (10: Byte) compareTo 2.0)
     assertEquals(1, (10: Byte) compareTo 2.0f)
 
+    assertEquals(0, 2.0 compareTo 2L)
+    assertEquals(-1, 2.0 compareTo 7540113804746346429L)
     assertEquals(0, 2.0 compareTo 2)
     assertEquals(0, 2.0 compareTo (2:Short))
     assertEquals(0, 2.0 compareTo (2:Byte))
@@ -51,6 +61,8 @@ fun box(): String {
     assertEquals(0, (2.0: Comparable<Double>) compareTo 2.0)
     assertEquals(0, 2.0 compareTo 2.0f)
 
+    assertEquals(1, 3.0f compareTo 2L)
+    assertEquals(-1, 3.0f compareTo 7540113804746346429L)
     assertEquals(1, 3.0f compareTo 2)
     assertEquals(1, 3.0f compareTo (2:Short))
     assertEquals(1, 3.0f compareTo (2:Byte))
@@ -58,6 +70,52 @@ fun box(): String {
     assertEquals(1, 3.0f compareTo 2.0f)
     assertEquals(1, (3.0f: Comparable<Float>) compareTo 2.0f)
 
+    assertEquals(1, 10L compareTo 2L)
+    assertEquals(-1, 10L compareTo 7540113804746346429L)
+    assertEquals(1, (10L: Comparable<Long>) compareTo 2L)
+    assertEquals(1, 10L compareTo 2)
+    assertEquals(1, 10L compareTo (2:Short))
+    assertEquals(1, 10L compareTo (2:Byte))
+    assertEquals(1, 10L compareTo 2.0)
+    assertEquals(1, 10L compareTo 2.0f)
+
+    assertEquals(-1, 1L compareTo 2L)
+    assertEquals(-1, 1L compareTo 2)
+    assertEquals(-1, 1L compareTo (2:Short))
+    assertEquals(-1, 1L compareTo (2:Byte))
+    assertEquals(-1, 1L compareTo 2.0)
+    assertEquals(-1, 1L compareTo 2.0f)
+
+    assertEquals(0, 7540113804746346429L compareTo 7540113804746346429L)
+    assertEquals(1, 7540113804746346429L compareTo 2L)
+    assertEquals(0, 2L compareTo 2L)
+    assertEquals(0, 2L compareTo 2)
+    assertEquals(0, 2L compareTo (2:Short))
+    assertEquals(0, 2L compareTo (2:Byte))
+    assertEquals(0, 2L compareTo 2.0)
+    assertEquals(0, 2L compareTo 2.0f)
+
+    assertEquals(1, 10L compareTo 2L)
+    assertEquals(1, 10L compareTo 2)
+    assertEquals(1, 10L compareTo (2:Short))
+    assertEquals(1, 10L compareTo (2:Byte))
+    assertEquals(1, 10L compareTo 2.0)
+    assertEquals(1, 10L compareTo 2.0f)
+
+    assertEquals(-1, 1L compareTo 2L)
+    assertEquals(-1, 1L compareTo 2)
+    assertEquals(-1, 1L compareTo (2:Short))
+    assertEquals(-1, 1L compareTo (2:Byte))
+    assertEquals(-1, 1L compareTo 2.0)
+    assertEquals(-1, 1L compareTo 2.0f)
+
+    assertEquals(0, 2L compareTo 2L)
+    assertEquals(0, 2L compareTo 2)
+    assertEquals(0, 2L compareTo (2:Short))
+    assertEquals(0, 2L compareTo (2:Byte))
+    assertEquals(0, 2L compareTo 2.0)
+    assertEquals(0, 2L compareTo 2.0f)
+
     assertEquals(1, id("A", 10) compareTo id("B", 5))
     assertEquals("AB", global)
 

js/js.translator/testData/number/cases/numberIsCheck.kt

@@ -8,6 +8,7 @@ fun testNum(numX: Number) {
 
     assertEquals(true, numX is Short, "numX is Short")
     assertEquals(true, numX is Byte, "numX is Byte")
+    assertEquals(false, numX is Long, "numX is Long")
 
     assertEquals(true, numX is Double, "numX is Double")
     assertEquals(true, numX is Float, "numX is Float")
@@ -19,6 +20,7 @@ fun testAny(anyX: Any) {
 
     assertEquals(true, anyX is Short, "anyX is Short")
     assertEquals(true, anyX is Byte, "anyX is Byte")
+    assertEquals(false, anyX is Long, "anyX is Long")
 
     assertEquals(true, anyX is Double, "anyX is Double")
     assertEquals(true, anyX is Float, "anyX is Float")
@@ -39,11 +41,11 @@ fun box(): String {
     testNum(100.0)
     testNum(100.0f)
 
-    testAny(100)
-    testAny(100: Short)
-    testAny(100: Byte)
-    testAny(100.0)
-    testAny(100.0f)
+    anyX = 100L
+    assertEquals(true, anyX is Number, "anyX is Number")
+    assertEquals(true, anyX is Long, "anyX is Long")
+    assertEquals(false, anyX is Int, "anyX is Int")
+
 
     return "OK"
 }