JS backend: tests for char type

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.k2js.test.semantics;
+
+import org.jetbrains.k2js.facade.exceptions.TranslationInternalException;
+import org.jetbrains.k2js.test.SingleFileTranslationTest;
+import org.junit.Assert;
+
+public final class CharTest extends SingleFileTranslationTest {
+    public CharTest() {
+        super("char/");
+    }
+
+    public void testCharIsCheck() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testCharConversions() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testCharCompareToIntrinsic() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testCharBinaryOperations() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testCharUnaryOperations() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testCharRanges() throws Exception {
+        checkFooBoxIsOk();
+    }
+
+    public void testCharEquals() throws Exception {
+        checkFooBoxIsOk();
+    }
+}

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

@@ -49,4 +49,8 @@ public final class RangeTest extends SingleFileTranslationTest {
     public void testRangeToDoesNotIterate() throws Exception {
         fooBoxTest();
     }
+
+    public void testRangeEquals() throws Exception {
+        checkFooBoxIsOk();
+    }
 }

js/js.translator/testData/char/cases/charBinaryOperations.kt

@@ -0,0 +1,77 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(75, 10 + 'A')
+    assertEquals(75, (10: Short) + 'A')
+    assertEquals(75, (10: Byte) + 'A')
+    assertEquals(75.0, 10.0 + 'A')
+    assertEquals(75.0, 10.0f + 'A')
+    assertEquals(75L, 10L + 'A')
+
+    assertEquals(75, 'A' + 10)
+    assertEquals(75, 'A' + (10: Short))
+    assertEquals(75, 'A' + (10: Byte))
+    assertEquals(75.0, 'A' + 10.0)
+    assertEquals(75.0, 'A' + 10.0f)
+    assertEquals(75L, 'A' + 10L)
+
+    assertEquals(-55, 10 - 'A')
+    assertEquals(-55, (10: Short) - 'A')
+    assertEquals(-55, (10: Byte) - 'A')
+    assertEquals(-55.0, 10.0 - 'A')
+    assertEquals(-55.0, 10.0f - 'A')
+    assertEquals(-55L, 10L - 'A')
+
+    assertEquals(55, 'A' - 10)
+    assertEquals(55, 'A' - (10: Short))
+    assertEquals(55, 'A' - (10: Byte))
+    assertEquals(55.0, 'A' - 10.0)
+    assertEquals(55.0, 'A' - 10.0f)
+    assertEquals(55L, 'A' - 10L)
+
+    assertEquals(650, 10 * 'A')
+    assertEquals(650, (10: Short) * 'A')
+    assertEquals(650, (10: Byte) * 'A')
+    assertEquals(650.0, 10.0 * 'A')
+    assertEquals(650.0, 10.0f * 'A')
+    assertEquals(650L, 10L * 'A')
+
+    assertEquals(650, 'A' * 10)
+    assertEquals(650, 'A' * (10: Short))
+    assertEquals(650, 'A' * (10: Byte))
+    assertEquals(650.0, 'A' * 10.0)
+    assertEquals(650.0, 'A' * 10.0f)
+    assertEquals(650L, 'A' * 10L)
+
+    assertEquals(1, 100 / 'A')
+    assertEquals(1, (100: Short) / 'A')
+    assertEquals(1, (100: Byte) / 'A')
+    assertEquals(100.0 / 65.0, 100.0 / 'A')
+    assertEquals(100.0 / 65.0, 100.0f / 'A')
+    assertEquals(1L, 100L / 'A')
+
+    assertEquals(6, 'A' / 10)
+    assertEquals(6, 'A' / (10: Short))
+    assertEquals(6, 'A' / (10: Byte))
+    assertEquals(6.5, 'A' / 10.0)
+    assertEquals(6.5, 'A' / 10.0f)
+    assertEquals(6L, 'A' / 10L)
+
+    assertEquals(35, 100 % 'A')
+    assertEquals(35, (100: Short) % 'A')
+    assertEquals(35, (100: Byte) % 'A')
+    // TODO Uncomment when KT-5860 (Double.mod(Char) is absent) will be fixed
+    //assertEquals(35.0, 100.0 % 'A')
+    assertEquals(35.0, 100.0f % 'A')
+    assertEquals(35L, 100L % 'A')
+
+    assertEquals(5, 'A' % 10)
+    assertEquals(5, 'A' % (10: Short))
+    assertEquals(5, 'A' % (10: Byte))
+    assertEquals(5.0, 'A' % 10.0)
+    assertEquals(5.0, 'A' % 10.0f)
+    assertEquals(5L, 'A' % 10L)
+
+    return "OK"
+}

js/js.translator/testData/char/cases/charCompareToIntrinsic.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(true, 64 < 'A')
+    assertEquals(true, (64: Short) < 'A')
+    assertEquals(true, (64: Byte) < 'A')
+    assertEquals(true, 64L < 'A')
+    assertEquals(true, 64.0 < 'A')
+    assertEquals(true, 64.0f < 'A')
+
+    assertEquals(true, 'A' > 64)
+    assertEquals(true, 'A' > (64: Short))
+    assertEquals(true, 'A' > (64: Byte))
+    assertEquals(true, 'A' > 64L)
+    assertEquals(true, 'A' > 64.0)
+    assertEquals(true, 'A' > 64.0f)
+
+    return "OK"
+}

js/js.translator/testData/char/cases/charConversions.kt

@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+
+    assertEquals('A', 'A'.toChar(), "toChar")
+    assertEquals(65, 'A'.toInt(), "toInt")
+    assertEquals(65: Short, 'A'.toShort(), "toShort")
+    assertEquals(65: Byte, 'A'.toByte(), "toByte")
+    assertEquals(65.0, 'A'.toDouble(), "toDouble")
+    assertEquals(65.0f, 'A'.toFloat(), "toFloat")
+    assertEquals(65L, 'A'.toLong(), "toLong")
+
+    return "OK"
+}

js/js.translator/testData/char/cases/charEquals.kt

@@ -0,0 +1,12 @@
+package foo
+
+class A
+
+fun box(): String {
+
+    assertEquals(true, 'A' == 'A')
+    assertEquals(false, 'A'== 'B')
+    assertEquals(false, ('A': Any) == (65: Any))
+
+    return "OK"
+}

js/js.translator/testData/char/cases/charIsCheck.kt

@@ -0,0 +1,18 @@
+package foo
+
+class A
+
+fun box(): String {
+
+    assertEquals(false, ('A': Any) is Int)
+    assertEquals(false, ('A': Any) is Short)
+    assertEquals(false, ('A': Any) is Byte)
+    assertEquals(false, ('A': Any) is Float)
+    assertEquals(false, ('A': Any) is Double)
+    assertEquals(false, ('A': Any) is Number)
+
+    assertEquals(true, 'A' is Char)
+    assertEquals(true, ('A': Any) is Char)
+
+    return "OK"
+}

js/js.translator/testData/char/cases/charRanges.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+
+    assertEquals(true, 'B' in 'A'..'D')
+    assertEquals(true, 'E' !in 'A'..'D')
+
+    var s = ""
+    for(char in 'A'..'D') {
+        s += char
+    }
+    assertEquals("ABCD", s)
+
+    return "OK"
+}

js/js.translator/testData/char/cases/charUnaryOperations.kt

@@ -0,0 +1,29 @@
+package foo
+
+fun box(): String {
+
+    var x: Char = 'A'
+    x++
+    assertEquals('B', x)
+    ++x
+    assertEquals('C', x)
+
+    var y = x++
+    assertEquals('C', y)
+    assertEquals('D', x)
+
+    y = ++x
+    assertEquals('E', y)
+    assertEquals('E', x)
+
+    x--
+    assertEquals('D', x)
+    --x
+    assertEquals('C', x)
+
+    assertEquals(67, +x)
+    assertEquals(-67, -x)
+
+
+    return "OK"
+}

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

@@ -27,6 +27,10 @@ fun box(): String {
     assertEquals(-12, -12.4.toShort())
     assertEquals(-12, -12.4.toByte())
 
+    assertEquals('\u0419', (-654311).toChar())
+    assertEquals('\u0419', (-654311.0).toChar())
+    assertEquals('\u0419', (-654311.0f).toChar())
+
     val longX: Long = 9223372034707292481L
     assertEquals("9223372034707292481", longX.toString())
     val doubleX: Double = safeParseDouble("9223372034707292481")!!
@@ -36,6 +40,7 @@ fun box(): String {
     assertEquals(-2147483327, longX.toInt())
     assertEquals(321, longX.toShort())
     assertEquals(65, longX.toByte())
+    assertEquals('\u0141', longX.toChar())
 
     val intX: Int = longX.toInt()
     assertEquals(321, intX.toShort())

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

@@ -7,6 +7,7 @@ fun testForNumber(numberX: Number) {
     assertEquals(true, 65 == numberX.toInt())
     assertEquals(true, (65: Short) == numberX.toShort())
     assertEquals(true, (65: Byte) == numberX.toByte())
+    assertEquals(true, 'A' == numberX.toChar())
 }
 
 fun box(): String {
@@ -25,6 +26,7 @@ fun box(): String {
     assertEquals(true, 65 == doubleX.toInt())
     assertEquals(true, (65: Short) == doubleX.toShort())
     assertEquals(true, (65: Byte) == doubleX.toByte())
+    assertEquals(true, 'A' == doubleX.toChar())
 
     var floatX: Float = 65.0f
     assertEquals(true, 65.0 == floatX.toDouble())
@@ -33,6 +35,7 @@ fun box(): String {
     assertEquals(true, 65 == floatX.toInt())
     assertEquals(true, (65: Short) == floatX.toShort())
     assertEquals(true, (65: Byte) == floatX.toByte())
+    assertEquals(true, 'A' == floatX.toChar())
 
     val longX: Long = 65L
     assertEquals(true, 65.0 == longX.toDouble())
@@ -41,6 +44,7 @@ fun box(): String {
     assertEquals(true, 65 == longX.toInt())
     assertEquals(true, (65: Short) == longX.toShort())
     assertEquals(true, (65: Byte) == longX.toByte())
+    assertEquals(true, 'A' == longX.toChar())
 
     val intX: Int = 65
     assertEquals(true, 65.0 == intX.toDouble())
@@ -49,6 +53,7 @@ fun box(): String {
     assertEquals(true, 65 == intX.toInt())
     assertEquals(true, (65: Short) == intX.toShort())
     assertEquals(true, (65: Byte) == intX.toByte())
+    assertEquals(true, 'A' == intX.toChar())
 
     val shortX: Short = 65: Short
     assertEquals(true, 65.0 == shortX.toDouble())
@@ -57,6 +62,7 @@ fun box(): String {
     assertEquals(true, 65 == shortX.toInt())
     assertEquals(true, (65: Short) == shortX.toShort())
     assertEquals(true, (65: Byte) == shortX.toByte())
+    assertEquals(true, 'A' == shortX.toChar())
 
     val byteX: Byte = 65: Byte
     assertEquals(true, 65.0 == byteX.toDouble())
@@ -65,6 +71,7 @@ fun box(): String {
     assertEquals(true, 65 == byteX.toInt())
     assertEquals(true, (65: Short) == byteX.toShort())
     assertEquals(true, (65: Byte) == byteX.toByte())
+    assertEquals(true, 'A' == byteX.toChar())
 
     return "OK"
 }

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

@@ -19,6 +19,7 @@ fun box(): String {
     assertEquals(-1, 1 compareTo (2:Byte))
     assertEquals(-1, 1 compareTo 2.0)
     assertEquals(-1, 1 compareTo 2.0f)
+    assertEquals(-1, 1 compareTo 'A')
 
     assertEquals(1, 10 compareTo 2L)
     assertEquals(1, 10 compareTo 2)
@@ -42,6 +43,7 @@ fun box(): String {
     assertEquals(-1, (1: Short) compareTo (2:Byte))
     assertEquals(-1, (1: Short) compareTo 2.0)
     assertEquals(-1, (1: Short) compareTo 2.0f)
+    assertEquals(-1, (1: Short) compareTo 'A')
 
     assertEquals(1, (10: Byte) compareTo 2L)
     assertEquals(-1, (10: Byte) compareTo 7540113804746346429L)
@@ -51,6 +53,7 @@ fun box(): String {
     assertEquals(1, ((10: Byte): Comparable<Byte>) compareTo (2:Byte))
     assertEquals(1, (10: Byte) compareTo 2.0)
     assertEquals(1, (10: Byte) compareTo 2.0f)
+    assertEquals(-1, (10: Byte) compareTo 'A')
 
     assertEquals(0, 2.0 compareTo 2L)
     assertEquals(-1, 2.0 compareTo 7540113804746346429L)
@@ -60,6 +63,7 @@ fun box(): String {
     assertEquals(0, 2.0 compareTo 2.0)
     assertEquals(0, (2.0: Comparable<Double>) compareTo 2.0)
     assertEquals(0, 2.0 compareTo 2.0f)
+    assertEquals(-1, 2.0 compareTo 'A')
 
     assertEquals(1, 3.0f compareTo 2L)
     assertEquals(-1, 3.0f compareTo 7540113804746346429L)
@@ -68,6 +72,7 @@ fun box(): String {
     assertEquals(1, 3.0f compareTo (2:Byte))
     assertEquals(1, 3.0f compareTo 2.0)
     assertEquals(1, 3.0f compareTo 2.0f)
+    assertEquals(-1, 3.0f compareTo 'A')
     assertEquals(1, (3.0f: Comparable<Float>) compareTo 2.0f)
 
     assertEquals(1, 10L compareTo 2L)
@@ -78,6 +83,16 @@ fun box(): String {
     assertEquals(1, 10L compareTo (2:Byte))
     assertEquals(1, 10L compareTo 2.0)
     assertEquals(1, 10L compareTo 2.0f)
+    assertEquals(-1, 10L compareTo 'A')
+
+    assertEquals(-1, 'A' compareTo 200L)
+    assertEquals(-1, 'A' compareTo 7540113804746346429L)
+    assertEquals(1, 'A' compareTo 2)
+    assertEquals(1, 'A' compareTo (2:Short))
+    assertEquals(1, 'A' compareTo (2:Byte))
+    assertEquals(1, 'A' compareTo 2.0)
+    assertEquals(1, 'A' compareTo 2.0f)
+    assertEquals(0, 'A' compareTo 'A')
 
     assertEquals(-1, 1L compareTo 2L)
     assertEquals(-1, 1L compareTo 2)

js/js.translator/testData/range/cases/rangeEquals.kt

@@ -0,0 +1,12 @@
+package foo
+
+fun box(): String {
+
+     assertEquals(true, 2..1 == 4..2, "2..1 == 4..2")
+     assertEquals(true, 2L..1L == 318238945677L..2L, "2L..1L == 318238945677L..2L")
+     assertEquals(false, (2..1): Any == (4L..2L): Any, "(2..1): Any == (4L..2L): Any")
+     assertEquals(true, 'B'..'A' == 'W'..'B', "'B'..'A' == 'W'..'B'")
+     assertEquals(false, (2..1): Any == ('B'..'A'): Any, "(2..1): Any == ('B'..'A'): Any")
+
+    return "OK"
+}