JS tests: added tests for dynamic.

js/js.translator/testData/dynamic/_commonFiles/common.js

@@ -0,0 +1,34 @@
+var bar = {
+    boo: function (a) {
+        return "bar.boo(" + a + ")";
+    },
+    invoke: function () {
+        return renderInvocation("bar.invoke", arguments)
+    },
+    num: 42,
+    str: "ok!",
+    obj: {
+        name: "bar.obj"
+    },
+    1: {
+        one: "1.one"
+    },
+    5: 0,
+    0 : "zero",
+    get: function(a, b, c) {
+        return renderInvocation("bar.get", arguments)
+    },
+    set: function(a, b, c) {
+        return renderInvocation("bar.set", arguments)
+    }
+};
+
+var arr = [{ it : "is", 1 : "object" }, 65, undefined, -2, "Yo!"];
+
+function baz() {
+    return renderInvocation("baz", arguments)
+}
+
+function renderInvocation(prefix, args) {
+    return prefix + "(" + Array.prototype.slice.call(args) + ")"
+}

js/js.translator/testData/dynamic/_commonFiles/common.kt

@@ -0,0 +1,29 @@
+package foo
+
+native
+var bar: dynamic = noImpl
+
+native
+var arr: dynamic = noImpl
+
+native
+var baz: dynamic = noImpl
+
+native
+val undefined: Nothing? = noImpl
+
+object t {
+    override fun toString() = "object t {}"
+}
+
+object n {
+    fun valueOf() = 42
+}
+
+fun testTrue(f: () -> Boolean) {
+    assertTrue(f(), f.toString())
+}
+
+fun testFalse(f: () -> Boolean) {
+    assertFalse(f(), f.toString())
+}

js/js.translator/testData/dynamic/cases/binaryOperations.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    assertEquals(60, a * 5)
+    assertEquals(-21.4, a - b)
+    assertEquals("12text", a + c)
+    assertEquals("text foo", c + " foo")
+    assertEquals("text33.4", c + b)
+    assertEquals("12[object Object]", a + bar)
+    assertEquals(2, a % 5)
+    assertEquals("42.35928143712575text[object Object]", a / b + d * n + c + bar)
+    assertEquals("12text[object Object]4233.4", a + c + bar + n + b)
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/callGetMethod.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.get()", bar.get())
+    assertEquals("bar.get(some text)", bar.get("some text"))
+    assertEquals("bar.get(1,2,3)", bar.get(1, 2, 3))
+    assertEquals("bar.get(1,second,2,3)", bar.get(1, "second", 2, 3))
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/callMethods.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.boo(23)", bar.boo(23))
+    assertEquals("bar.boo(Hello)", bar.boo("Hello"))
+    assertEquals("bar.boo(object t {})", bar.boo(t))
+    assertEquals("bar.boo(null)", bar.boo(null))
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/callSetMethod.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.set()", bar.set())
+    assertEquals("bar.set(some text)", bar.set("some text"))
+    assertEquals("bar.set(1,2,3)", bar.set(1, 2, 3))
+    assertEquals("bar.set(1,second,2,3)", bar.set(1, "second", 2, 3))
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/compareTo.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    testFalse { a > b }
+    testTrue { b <= 34 }
+    testTrue { c >= "text" }
+    testFalse { c <= "abc" }
+    testTrue { d >= 1 }
+    testFalse { d <= 0 }
+    testTrue { d && true }
+    testTrue { false || d }
+    testFalse { d && a < c }
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/equals.kt

@@ -0,0 +1,51 @@
+package foo
+
+object f {
+    var equalsCalled = false
+
+    override fun equals(other: Any?): Boolean {
+        equalsCalled = true
+        return super.equals(other)
+    }
+}
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    val v: dynamic = 42
+    val tt: dynamic = "object t {}"
+
+    testFalse { a == 34 }
+    testFalse { a == "34" }
+    testTrue { a == 12 }
+    testTrue { a == "12" }
+    testFalse { a != 12 }
+    testFalse { a != "12" }
+    testTrue { c == "text" }
+    testTrue { d == 1 }
+    testFalse { d == 0 }
+    testFalse { c != "text" }
+    testTrue { v == n }
+    testTrue { tt == t }
+    testFalse { v == bar }
+    testTrue { n != bar }
+
+    testFalse { a.equals(34) }
+    testFalse { a.equals("34") }
+    testTrue { a.equals(12) }
+    testFalse { a.equals("12") }
+
+    testFalse { a equals 34 }
+    testFalse { a equals "34" }
+    testTrue { a equals 12 }
+    testFalse { a equals "12" }
+
+    val ff: dynamic = f
+    testFalse { ff.equals(v) }
+    assertTrue(f.equalsCalled, "f.equalsCalled")
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/getByBrackets.kt

@@ -0,0 +1,36 @@
+package foo
+
+fun box(): String {
+    assertEquals(42, bar["num"])
+    assertEquals("ok!", bar["str"])
+    assertEquals(bar.obj, bar["obj"])
+    assertEquals("zero", bar[0])
+    assertEquals("e", bar[0][1])
+    assertEquals(0, bar[5])
+    assertEquals("1.one", bar[1].one)
+    assertEquals("bar.obj", bar.obj["name"])
+    assertEquals("bar.obj", bar["obj"]["name"])
+    assertEquals("baz", baz["name"])
+    assertEquals(0, baz["length"])
+    assertEquals("is", arr["0"].it)
+    assertEquals("object", arr["0"][1])
+    assertEquals("is", arr[0]["it"])
+    assertEquals(undefined, arr[2])
+    assertEquals(-2, arr[3])
+    assertEquals(5, arr["length"])
+
+    assertEquals(undefined, bar["num0"])
+    assertEquals(undefined, bar["STR"])
+    assertEquals(undefined, bar[2])
+    assertEquals(undefined, bar.obj["foo"])
+    assertEquals(undefined, bar["obj"].foo)
+    assertEquals(undefined, bar["obj"]["foo"])
+    assertEquals(undefined, baz[3])
+    assertEquals(undefined, baz["function"])
+    assertEquals(undefined, arr["6"])
+    assertEquals(undefined, arr[7])
+    assertEquals(undefined, arr[10])
+    assertEquals(undefined, arr["name"])
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/identityEquals.kt

@@ -0,0 +1,28 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    val v: dynamic = 42
+    val tt: dynamic = "object t {}"
+
+    testFalse { a === 34 }
+    testFalse { a === "34" }
+    testTrue { a === 12 }
+    testFalse { a === "12" }
+    testFalse { a !== 12 }
+    testTrue { a !== "12" }
+    testTrue { c === "text" }
+    testFalse { d === 1 }
+    testFalse { d === 0 }
+    testFalse { c !== "text" }
+    testFalse { v === n }
+    testFalse { tt === t }
+    testFalse { v === bar }
+    testTrue { n !== bar }
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/in.kt

@@ -0,0 +1,57 @@
+package foo
+
+fun box(): String {
+    testTrue { "num" in bar }
+    testTrue { "str" in bar }
+    testTrue { "obj" in bar }
+    testTrue { 0 in bar }
+    testTrue { 5 in bar }
+    testTrue { 1 in bar }
+    testTrue { "name" in bar.obj }
+    testTrue { "name" in baz }
+    testTrue { "length" in baz }
+    testTrue { "0" in arr }
+    testTrue { 0 in arr }
+    testTrue { 2 in arr }
+    testTrue { 3 in arr }
+    testTrue { "length" in arr }
+
+    testFalse { "num" !in bar }
+    testFalse { "str" !in bar }
+    testFalse { "obj" !in bar }
+    testFalse { 0 !in bar }
+    testFalse { 5 !in bar }
+    testFalse { 1 !in bar }
+    testFalse { "name" !in bar.obj }
+    testFalse { "name" !in baz }
+    testFalse { "length" !in baz }
+    testFalse { "0" !in arr }
+    testFalse { 0 !in arr }
+    testFalse { 2 !in arr }
+    testFalse { 3 !in arr }
+    testFalse { "length" !in arr }
+
+    testFalse { "num0" in bar }
+    testFalse { "STR" in bar }
+    testFalse { 2 in bar }
+    testFalse { "foo" in bar.obj }
+    testFalse { 3 in baz }
+    testFalse { "function" in baz }
+    testFalse { "6" in arr }
+    testFalse { 7 in arr }
+    testFalse { 10 in arr }
+    testFalse { "name" in arr }
+
+    testTrue { "num0" !in bar }
+    testTrue { "STR" !in bar }
+    testTrue { 2 !in bar }
+    testTrue { "foo" !in bar.obj }
+    testTrue { 3 !in baz }
+    testTrue { "function" !in baz }
+    testTrue { "6" !in arr }
+    testTrue { 7 !in arr }
+    testTrue { 10 !in arr }
+    testTrue { "name" !in arr }
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/incrementAndDecrement.kt

@@ -0,0 +1,28 @@
+package foo
+
+fun box(): String {
+    var a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    assertEquals(11, --a)
+    assertEquals(11, a)
+    assertEquals(11, a--)
+    assertEquals(10, a)
+    assertEquals(10, a++)
+    assertEquals(11, a)
+    assertEquals(12, ++a)
+    assertEquals(12, a)
+
+    assertEquals(32.4, --b)
+    assertEquals(32.4, b)
+    assertEquals(32.4, b--)
+    assertEquals(31.4, b)
+    assertEquals(31.4, b++)
+    assertEquals(32.4, b)
+    assertEquals(33.4, ++b)
+    assertEquals(33.4, b)
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/infixCall.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.boo(23)", bar boo 23)
+    assertEquals("bar.boo(Hello)", bar boo "Hello")
+    assertEquals("bar.boo(object t {})", bar boo t)
+    assertEquals("bar.boo(null)", bar boo null)
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/invoke.kt

@@ -0,0 +1,9 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.invoke(32,object t {})", bar.invoke(32, t))
+    assertEquals("bar.invoke(77)", bar invoke 77)
+    assertEquals("baz(object t {},object t {})", baz(t, t))
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/is.js

@@ -0,0 +1,2 @@
+function B() {
+}

js/js.translator/testData/dynamic/cases/is.kt

@@ -0,0 +1,18 @@
+package foo
+
+class A
+
+native
+class B
+
+fun box(): String {
+    val a: dynamic = A()
+    testTrue { a is A }
+    testFalse { a is B }
+
+    val b: dynamic = B()
+    testTrue { b is B }
+    testFalse { b is A }
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/isJsPrimitiveType.kt

@@ -0,0 +1,32 @@
+package foo
+
+enum class Type {
+    NUMBER
+    STRING
+    BOOLEAN
+    OBJECT
+}
+
+fun test(a: dynamic, actualType: Type) {
+    assertEquals(actualType == Type.NUMBER, a is Int, "$a is Int")
+    assertEquals(actualType == Type.NUMBER, a is Number, "$a is Number")
+    assertEquals(actualType == Type.NUMBER, a is Double, "$a is Double")
+    assertEquals(actualType == Type.BOOLEAN, a is Boolean, "$a is Boolean")
+    assertEquals(actualType == Type.STRING, a is String, "$a is String")
+}
+
+fun box(): String {
+    test(1, Type.NUMBER)
+
+    test(12.3, Type.NUMBER)
+    test(12.3f, Type.NUMBER)
+
+    test("text", Type.STRING)
+
+    test(true, Type.BOOLEAN)
+    test(false, Type.BOOLEAN)
+
+    test(object {}, Type.OBJECT)
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/operationsWithAssignment.kt

@@ -0,0 +1,25 @@
+package foo
+
+fun box(): String {
+    var a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    a += d
+    assertEquals(13, a)
+    c += a
+    assertEquals("text13", c)
+    a %= 7
+    assertEquals(6, a)
+    b -= 32
+    assertEquals(1.3999999999999986, b)
+    b *= n
+    assertEquals(58.79999999999994, b)
+    b /= a
+    assertEquals(9.79999999999999, b)
+    c += a * 3 + b / n
+    assertEquals("text1318.233333333333334", c)
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/propertyAccess.kt

@@ -0,0 +1,38 @@
+package foo
+
+fun box(): String {
+    assertEquals(42, bar.num)
+    assertEquals("ok!", bar.str)
+    assertEquals("bar.obj", bar.obj.name)
+    assertEquals("baz", baz.name)
+
+    assertEquals(undefined, bar.num0)
+    assertEquals(undefined, bar.str0)
+    assertEquals(undefined, bar.obj.noname)
+    assertEquals(undefined, baz.boo)
+
+
+    bar.num = 22
+    assertEquals(22, bar.num)
+
+    bar.str = undefined
+    assertEquals(undefined, bar.str)
+
+    bar.obj.name = "new bar.obj"
+    assertEquals("new bar.obj", bar.obj.name)
+
+
+    bar.num0 = 100
+    assertEquals(100, bar.num0)
+
+    bar.str0 = "new str"
+    assertEquals("new str", bar.str0)
+
+    bar.obj.noname = "noname value"
+    assertEquals("noname value", bar.obj.noname)
+
+    baz.boo = "baz"
+    assertEquals("baz", baz.boo)
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/setByBrackets.kt

@@ -0,0 +1,62 @@
+package foo
+
+fun box(): String {
+    bar["num"] = "some"
+    assertEquals("some", bar["num"])
+
+    bar["str"] = "OK!"
+    assertEquals("OK!", bar["str"])
+
+    var tmp = bar["obj"]
+    bar["obj"] = bar[0]
+    bar[0] = tmp
+    assertEquals("zero", bar["obj"])
+    assertEquals(tmp, bar[0])
+    assertEquals("bar.obj", bar[0].name)
+
+    bar[5] = 27
+    assertEquals(27, bar[5])
+
+    bar[0]["name"] = "new name"
+    assertEquals("new name", bar[0]["name"])
+
+    arr["0"].it = 23
+    assertEquals(23, arr["0"].it)
+
+    arr[0][1] = "ooo"
+    assertEquals("ooo", arr[0][1])
+
+    arr[2] = 37
+    assertEquals(37, arr[2])
+
+    arr[3] = 77
+    assertEquals(77, arr[3])
+
+    arr["length"] = 3
+    assertEquals(3, arr["length"])
+
+
+    bar["num0"] = "new value"
+    assertEquals("new value", bar["num0"])
+
+    bar["STR"] = 12
+    assertEquals(12, bar["STR"])
+
+
+    bar[2] = "bar[2]"
+    assertEquals("bar[2]", bar[2])
+
+    arr["6"] = "0"
+    assertEquals("0", arr["6"])
+    assertEquals(7, arr.length)
+
+    arr[10] = 15
+    assertEquals(undefined, arr[7])
+    assertEquals(15, arr[10])
+    assertEquals(11, arr.length)
+
+    arr["name"] = "My Array"
+    assertEquals("My Array", arr["name"])
+
+    return "OK"
+}

js/js.translator/testData/dynamic/cases/unaryOperations.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    assertEquals(-12, -a)
+    assertEquals(33.4, +b)
+    testTrue { d }
+    testFalse { !d }
+    testTrue { !!d }
+    testFalse { !a }
+    testTrue { !!a }
+    testFalse { !b }
+    testTrue { !!b }
+
+    return "OK"
+}