JS: move more test to box tests

2016-08-30 14:59:26 +03:00
parent 7e2d5b04de
commit 3801052460
112 changed files with 760 additions and 676 deletions
@@ -0,0 +1,9 @@
+package foo
+
+fun box(): String {
+
+    val a = arrayOfNulls<Int>(2)
+    a.set(1, 2)
+    return if (a.get(1) == 2) "OK" else "fail"
+}
+
@@ -0,0 +1,8 @@
+package foo
+
+fun box(): String {
+    val a = arrayOfNulls<Int>(4)
+    a[1] = 2
+    a[2] = 3
+    return if ((a[1] == 2) && (a[2] == 3)) "OK" else "fail"
+}
@@ -0,0 +1,25 @@
+package foo
+
+fun box(): String {
+    val s = Array<String>(3) { it.toString() }
+    if (s.size != 3) return "Fail Array size: ${s.size}"
+    if (s[1] != "1") return "Fail Array value: ${s[1]}"
+
+    val i = IntArray(3) { it }
+    if (i.size != 3) return "Fail IntArray size: ${i.size}"
+    if (i[1] != 1) return "Fail IntArray value: ${i[1]}"
+
+    val c = CharArray(3) { it.toChar() }
+    if (c.size != 3) return "Fail CharArray size: ${c.size}"
+    if (c[1] != 1.toChar()) return "Fail CharArray value: ${c[1]}"
+
+    val b = BooleanArray(3) { true }
+    if (b.size != 3) return "Fail BooleanArray size: ${b.size}"
+    if (b[1] != true) return "Fail BooleanArray value: ${b[1]}"
+
+    val l = LongArray(3) { it.toLong() }
+    if (l.size != 3) return "Fail LongArray size: ${l.size}"
+    if (l[1] != 1L) return "Fail LongArray value: ${l[1]}"
+
+    return "OK"
+}
@@ -0,0 +1,38 @@
+package foo
+
+class Fail(message: String) : Exception(message)
+
+fun test(testName: String, actual: Any, expectedAsString: String) {
+    val expected = eval("[$expectedAsString]") as Array<in Any>
+    val expectedJs: dynamic = expected
+    val actualJs: dynamic = actual
+    if (expectedJs.length != actualJs.length) {
+        fail("Lengths do not match: ${expectedJs} vs. ${actualJs}")
+    }
+    for (index in 0..(expectedJs.length)) {
+        val expectedElem = expectedJs[index] as Any?
+        val actualElem = actualJs[index] as Any?
+        if (expectedElem != actualElem) {
+            fail("Content do not match: ${expectedJs} vs. ${actualJs}")
+        }
+    }
+}
+
+fun box(): String {
+    try {
+        test("arrayOf", arrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("booleanArrayOf", booleanArrayOf(true, false, false, true, true), "true, false, false, true, true")
+        test("charArray'", charArrayOf('0', '1', '2', '3', '4'), "'0', '1', '2', '3', '4'")
+        test("byteArrayOf", byteArrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("shortArrayOf", shortArrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("intArray,", intArrayOf(0, 1, 2, 3, 4), "0, 1, 2, 3, 4")
+        test("longArrayOf", longArrayOf(0, 1, 2, 3, 4), "kotlin.Long.fromInt(0), kotlin.Long.fromInt(1), kotlin.Long.fromInt(2), kotlin.Long.fromInt(3), kotlin.Long.fromInt(4)")
+        test("floatArrayOf", floatArrayOf(0.0f, 1.0f, 2.0f, 3.0f, 4.0f), "0.0, 1.0, 2.0, 3.0, 4.0")
+        test("doubleArrayOf", doubleArrayOf(0.0, 1.1, 2.2, 3.3, 4.4), "0.0, 1.1, 2.2, 3.3, 4.4")
+    }
+    catch (e: Fail) {
+        return e.message!!
+    }
+
+    return "OK"
+}
@@ -0,0 +1,7 @@
+package foo
+
+val f = { i: Int -> i + 1 }
+
+val a = Array(3, f)
+
+fun box() = if (a[0] == 1 && a[2] == 3 && a[1] == 2) "OK" else "fail"
@@ -0,0 +1,5 @@
+package foo
+
+val a = arrayOfNulls<Int>(3)
+
+fun box() = if (a[0] == null && a[1] == null && a[2] == null) "OK" else "fail"
@@ -0,0 +1,9 @@
+package foo
+
+class A() {
+}
+
+val a1 = arrayOfNulls<Int>(3)
+val a2 = arrayOfNulls<A>(2)
+
+fun box() = if (a1.size == 3 && a2.size == 2) "OK" else "fail"
@@ -0,0 +1,16 @@
+package foo
+
+val a1 = Array<Int>(3, { i: Int -> i })
+
+fun box(): String {
+    val i = a1.iterator()
+    if (i.hasNext() != true) return "fail1"
+    if (i.next() != 0) return "fail2"
+    if (i.hasNext() != true) return "fail3"
+    if (i.next() != 1) return "fail4"
+    if (i.hasNext() != true) return "fail5"
+    if (i.next() != 2) return "fail6"
+    if (i.hasNext() != false) return "fail7"
+
+    return "OK"
+}
@@ -0,0 +1,86 @@
+package foo
+
+import java.util.HashMap
+
+fun box(): String {
+
+    val x = true
+    val y = false
+
+    val mapWithIntKeys = HashMap<Int, Int>()
+    mapWithIntKeys[1] = 1
+    assertEquals("number", jsTypeOf (mapWithIntKeys.keys.iterator().next()), "mapWithIntKeys")
+
+    val mapWithShortKeys = HashMap<Short, Int>()
+    mapWithShortKeys[1.toShort()] = 1
+    assertEquals("number", jsTypeOf (mapWithShortKeys.keys.iterator().next()), "mapWithShortKeys")
+
+    val mapWithByteKeys = HashMap<Byte, Int>()
+    mapWithByteKeys[1.toByte()] = 1
+    assertEquals("number", jsTypeOf (mapWithByteKeys.keys.iterator().next()), "mapWithByteKeys")
+
+    val mapWithDoubleKeys = HashMap<Double, Int>()
+    mapWithDoubleKeys[1.0] = 1
+    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keys.iterator().next()), "mapWithDoubleKeys")
+
+    // boxed NaNs are not equal, KT-13610
+//    mapWithDoubleKeys.clear()
+//    var dNaN = 0.0 / 0.0
+//    mapWithDoubleKeys[dNaN] = 100
+//    assertEquals(100, mapWithDoubleKeys[dNaN])
+//    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keys.iterator().next()), "dNaN")
+
+    mapWithDoubleKeys.clear()
+    var dPositiveInfinity = +1.0 / 0.0
+    mapWithDoubleKeys[dPositiveInfinity] = 100
+    assertEquals(100, mapWithDoubleKeys[dPositiveInfinity])
+    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keys.iterator().next()), "dPositiveInfinity")
+
+    mapWithDoubleKeys.clear()
+    var dNegativeInfinity = -1.0 / 0.0
+    mapWithDoubleKeys[dNegativeInfinity] = 100
+    assertEquals(100, mapWithDoubleKeys[dNegativeInfinity])
+    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keys.iterator().next()), "dNegativeInfinity")
+
+    val mapWithFloatKeys = HashMap<Float, Int>()
+    mapWithFloatKeys[1.0f] = 1
+    assertEquals("number", jsTypeOf (mapWithFloatKeys.keys.iterator().next()), "mapWithFloatKeys")
+
+    // boxed NaNs are not equal, KT-13610
+//    mapWithFloatKeys.clear()
+//    var fNaN: Float = 0.0f / 0.0f
+//    mapWithFloatKeys[fNaN] = 100
+//    assertEquals(100, mapWithFloatKeys[fNaN])
+//    assertEquals("number", jsTypeOf (mapWithFloatKeys.keys.iterator().next()), "fNaN")
+
+    mapWithFloatKeys.clear()
+    var fPositiveInfinity = +1.0f / 0.0f
+    mapWithFloatKeys[fPositiveInfinity] = 100
+    assertEquals(100, mapWithFloatKeys[fPositiveInfinity])
+    assertEquals("number", jsTypeOf (mapWithFloatKeys.keys.iterator().next()), "fPositiveInfinity")
+
+    mapWithFloatKeys.clear()
+    var NegativeInfinity = -1.0f / 0.0f
+    mapWithFloatKeys[NegativeInfinity] = 100
+    assertEquals(100, mapWithFloatKeys[NegativeInfinity])
+    assertEquals("number", jsTypeOf (mapWithFloatKeys.keys.iterator().next()), "fNegativeInfinity")
+
+    val mapWithCharKeys = HashMap<Char, Int>()
+    mapWithCharKeys['A'] = 1
+    assertEquals("string", jsTypeOf (mapWithCharKeys.keys.iterator().next()), "mapWithCharKeys")
+
+    val mapWithLongKeys = HashMap<Long, Int>()
+    mapWithLongKeys[1L] = 1
+    assertEquals("object", jsTypeOf (mapWithLongKeys.keys.iterator().next()), "mapWithLongKeys")
+
+    val mapWithBooleanKeys = HashMap<Boolean, Int>()
+    mapWithBooleanKeys[true] = 1
+    assertEquals("boolean", jsTypeOf (mapWithBooleanKeys.keys.iterator().next()), "mapWithBooleanKeys")
+
+    val mapWithStringKeys = HashMap<String, Int>()
+    mapWithStringKeys["key"] = 1
+    assertEquals("string", jsTypeOf (mapWithStringKeys.keys.iterator().next()), "mapWithStringKeys")
+
+    return "OK"
+}
+
@@ -0,0 +1,72 @@
+package foo
+
+import java.util.HashSet
+
+fun box(): String {
+
+    val x = true
+    val y = false
+
+    val intSet = HashSet<Int>()
+    intSet.add(1)
+    assertEquals("number", jsTypeOf (intSet.iterator().next()), "intSet")
+
+    val shortSet = HashSet<Short>()
+    shortSet.add(1.toShort())
+    assertEquals("number", jsTypeOf (shortSet.iterator().next()), "shortSet")
+
+    val byteSet = HashSet<Byte>()
+    byteSet.add(1.toByte())
+    assertEquals("number", jsTypeOf (byteSet.iterator().next()), "byteSet")
+
+    val doubleSet = HashSet<Double>()
+    doubleSet.add(1.0)
+    assertEquals("number", jsTypeOf (doubleSet.iterator().next()), "doubleSet")
+
+    doubleSet.clear()
+    doubleSet.add(0.0 / 0.0)
+    assertEquals("number", jsTypeOf (doubleSet.iterator().next()), "dNaN")
+
+    doubleSet.clear()
+    doubleSet.add(1.0 / 0.0)
+    assertEquals("number", jsTypeOf (doubleSet.iterator().next()), "dPositiveInfinity")
+
+    doubleSet.clear()
+    doubleSet.add(-1.0 / 0.0)
+    assertEquals("number", jsTypeOf (doubleSet.iterator().next()), "dNegativeInfinity")
+
+    val floatSet = HashSet<Float>()
+    floatSet.add(1.0f)
+    assertEquals("number", jsTypeOf (floatSet.iterator().next()), "floatSet")
+
+    floatSet.clear()
+    floatSet.add(0.0f / 0.0f)
+    assertEquals("number", jsTypeOf (floatSet.iterator().next()), "fNaN")
+
+    floatSet.clear()
+    floatSet.add(+1.0f / 0.0f)
+    assertEquals("number", jsTypeOf (floatSet.iterator().next()), "fPositiveInfinity")
+
+    floatSet.clear()
+    floatSet.add(-1.0f / 0.0f)
+    assertEquals("number", jsTypeOf (floatSet.iterator().next()), "fNegativeInfinity")
+
+    val charSet = HashSet<Char>()
+    charSet.add('A')
+    assertEquals("string", jsTypeOf (charSet.iterator().next()), "charSet")
+
+    val longSet = HashSet<Long>()
+    longSet.add(1L)
+    assertEquals("object", jsTypeOf (longSet.iterator().next()), "longSet")
+
+    val booleanSet = HashSet<Boolean>()
+    booleanSet.add(true)
+    assertEquals("boolean", jsTypeOf (booleanSet.iterator().next()), "booleanSet")
+
+    val stringSet = HashSet<String>()
+    stringSet.add("text")
+    assertEquals("string", jsTypeOf (stringSet.iterator().next()), "stringSet")
+
+    return "OK"
+}
+
@@ -0,0 +1,22 @@
+package foo
+
+class A {
+    override fun hashCode() = 23456
+}
+
+fun box(): String {
+    val x = A()
+    val y = A()
+
+    val map = mutableMapOf<A, Int>()
+    map[x] = 1
+    assertEquals(1, map.size)
+
+    map.remove(y)
+    assertEquals(1, map.size)
+
+    map.remove(x)
+    assertEquals(0, map.size)
+
+    return "OK"
+}
@@ -0,0 +1,12 @@
+package foo
+
+
+fun box(): String {
+    val s = StringBuilder()
+    s.append("a")
+    s.append("b").append("c")
+    s.append('d').append("e")
+
+    if (s.toString() != "abcde") return s.toString()
+    return "OK"
+}