From 2e4e5c5d1dc00793506698cc162c7fd67251ef27 Mon Sep 17 00:00:00 2001 From: Michael Nedzelsky Date: Tue, 23 Sep 2014 19:02:33 +0400 Subject: [PATCH] JS backend: tests for Long type support --- .../k2js/test/semantics/NumberTest.java | 24 ++++++++ .../for/cases/forIteratesOverArray.kt | 6 ++ .../for/cases/forIteratesOverLiteralRange.kt | 10 ++++ .../cases/forIteratesOverNonLiteralRange.kt | 12 ++++ .../number/cases/conversionsWithTruncation.kt | 18 ++++++ .../cases/conversionsWithoutTruncation.kt | 15 +++++ .../testData/number/cases/longArray.kt | 22 +++++++ .../number/cases/longBinaryOperations.kt | 53 ++++++++++++++++ .../number/cases/longBitOperations.kt | 23 +++++++ .../number/cases/longCompareToIntrinsic.kt | 40 +++++++++++++ .../number/cases/longEqualsIntrinsic.kt | 31 ++++++++++ .../number/cases/longUnaryOperations.kt | 31 ++++++++++ .../testData/number/cases/numberCompareTo.kt | 60 ++++++++++++++++++- .../testData/number/cases/numberIsCheck.kt | 12 ++-- 14 files changed, 351 insertions(+), 6 deletions(-) create mode 100644 js/js.translator/testData/number/cases/longArray.kt create mode 100644 js/js.translator/testData/number/cases/longBinaryOperations.kt create mode 100644 js/js.translator/testData/number/cases/longBitOperations.kt create mode 100644 js/js.translator/testData/number/cases/longCompareToIntrinsic.kt create mode 100644 js/js.translator/testData/number/cases/longEqualsIntrinsic.kt create mode 100644 js/js.translator/testData/number/cases/longUnaryOperations.kt diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/NumberTest.java b/js/js.tests/test/org/jetbrains/k2js/test/semantics/NumberTest.java index 7b6b67d1e29..e29d66881a3 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/semantics/NumberTest.java +++ b/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(); + } } diff --git a/js/js.translator/testData/expression/for/cases/forIteratesOverArray.kt b/js/js.translator/testData/expression/for/cases/forIteratesOverArray.kt index 7d711edeb66..8f41cf1da65 100644 --- a/js/js.translator/testData/expression/for/cases/forIteratesOverArray.kt +++ b/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 } \ No newline at end of file diff --git a/js/js.translator/testData/expression/for/cases/forIteratesOverLiteralRange.kt b/js/js.translator/testData/expression/for/cases/forIteratesOverLiteralRange.kt index 627b7ec2f18..3f7a72c7739 100644 --- a/js/js.translator/testData/expression/for/cases/forIteratesOverLiteralRange.kt +++ b/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" } \ No newline at end of file diff --git a/js/js.translator/testData/expression/for/cases/forIteratesOverNonLiteralRange.kt b/js/js.translator/testData/expression/for/cases/forIteratesOverNonLiteralRange.kt index b17bc0ccbf1..ab5c5a25ed5 100644 --- a/js/js.translator/testData/expression/for/cases/forIteratesOverNonLiteralRange.kt +++ b/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" } \ No newline at end of file diff --git a/js/js.translator/testData/number/cases/conversionsWithTruncation.kt b/js/js.translator/testData/number/cases/conversionsWithTruncation.kt index 1fae0dbbf68..670711b7286 100644 --- a/js/js.translator/testData/number/cases/conversionsWithTruncation.kt +++ b/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" } diff --git a/js/js.translator/testData/number/cases/conversionsWithoutTruncation.kt b/js/js.translator/testData/number/cases/conversionsWithoutTruncation.kt index bdf7cbeafc3..df8c24e796c 100644 --- a/js/js.translator/testData/number/cases/conversionsWithoutTruncation.kt +++ b/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()) diff --git a/js/js.translator/testData/number/cases/longArray.kt b/js/js.translator/testData/number/cases/longArray.kt new file mode 100644 index 00000000000..d10ae94eb39 --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/number/cases/longBinaryOperations.kt b/js/js.translator/testData/number/cases/longBinaryOperations.kt new file mode 100644 index 00000000000..bdea46b14cc --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/number/cases/longBitOperations.kt b/js/js.translator/testData/number/cases/longBitOperations.kt new file mode 100644 index 00000000000..7582b0fbf49 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/number/cases/longCompareToIntrinsic.kt b/js/js.translator/testData/number/cases/longCompareToIntrinsic.kt new file mode 100644 index 00000000000..779d28def12 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/number/cases/longEqualsIntrinsic.kt b/js/js.translator/testData/number/cases/longEqualsIntrinsic.kt new file mode 100644 index 00000000000..643d6c18b8f --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/number/cases/longUnaryOperations.kt b/js/js.translator/testData/number/cases/longUnaryOperations.kt new file mode 100644 index 00000000000..d8682d19624 --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/number/cases/numberCompareTo.kt b/js/js.translator/testData/number/cases/numberCompareTo.kt index 762978e3520..068d79d1ebc 100644 --- a/js/js.translator/testData/number/cases/numberCompareTo.kt +++ b/js/js.translator/testData/number/cases/numberCompareTo.kt @@ -12,24 +12,30 @@ fun box(): String { assertEquals(-1, 1.compareTo(2)) assertEquals(-1, (1: Comparable).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) 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) 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) compareTo 2.0f) + assertEquals(1, 10L compareTo 2L) + assertEquals(-1, 10L compareTo 7540113804746346429L) + assertEquals(1, (10L: Comparable) 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) diff --git a/js/js.translator/testData/number/cases/numberIsCheck.kt b/js/js.translator/testData/number/cases/numberIsCheck.kt index 963f2eb2438..437287630dd 100644 --- a/js/js.translator/testData/number/cases/numberIsCheck.kt +++ b/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" } \ No newline at end of file