From af82e692142ba58cb49fe0fc2c47d061261ff98f Mon Sep 17 00:00:00 2001 From: Zalim Bashorov Date: Tue, 9 Dec 2014 23:07:25 +0300 Subject: [PATCH] JS tests: added tests for dynamic. --- .../jet/generators/tests/GenerateTests.kt | 5 + .../test/semantics/AbstractDynamicTest.kt | 21 +++ .../test/semantics/DynamicTestGenerated.java | 146 ++++++++++++++++++ .../testData/_commonFiles/asserts.kt | 2 + .../testData/dynamic/_commonFiles/common.js | 34 ++++ .../testData/dynamic/_commonFiles/common.kt | 29 ++++ .../dynamic/cases/binaryOperations.kt | 20 +++ .../testData/dynamic/cases/callGetMethod.kt | 10 ++ .../testData/dynamic/cases/callMethods.kt | 10 ++ .../testData/dynamic/cases/callSetMethod.kt | 10 ++ .../testData/dynamic/cases/compareTo.kt | 20 +++ .../testData/dynamic/cases/equals.kt | 51 ++++++ .../testData/dynamic/cases/getByBrackets.kt | 36 +++++ .../testData/dynamic/cases/identityEquals.kt | 28 ++++ js/js.translator/testData/dynamic/cases/in.kt | 57 +++++++ .../dynamic/cases/incrementAndDecrement.kt | 28 ++++ .../testData/dynamic/cases/infixCall.kt | 10 ++ .../testData/dynamic/cases/invoke.kt | 9 ++ js/js.translator/testData/dynamic/cases/is.js | 2 + js/js.translator/testData/dynamic/cases/is.kt | 18 +++ .../dynamic/cases/isJsPrimitiveType.kt | 32 ++++ .../dynamic/cases/operationsWithAssignment.kt | 25 +++ .../testData/dynamic/cases/propertyAccess.kt | 38 +++++ .../testData/dynamic/cases/setByBrackets.kt | 62 ++++++++ .../testData/dynamic/cases/unaryOperations.kt | 20 +++ 25 files changed, 723 insertions(+) create mode 100644 js/js.tests/test/org/jetbrains/k2js/test/semantics/AbstractDynamicTest.kt create mode 100644 js/js.tests/test/org/jetbrains/k2js/test/semantics/DynamicTestGenerated.java create mode 100644 js/js.translator/testData/dynamic/_commonFiles/common.js create mode 100644 js/js.translator/testData/dynamic/_commonFiles/common.kt create mode 100644 js/js.translator/testData/dynamic/cases/binaryOperations.kt create mode 100644 js/js.translator/testData/dynamic/cases/callGetMethod.kt create mode 100644 js/js.translator/testData/dynamic/cases/callMethods.kt create mode 100644 js/js.translator/testData/dynamic/cases/callSetMethod.kt create mode 100644 js/js.translator/testData/dynamic/cases/compareTo.kt create mode 100644 js/js.translator/testData/dynamic/cases/equals.kt create mode 100644 js/js.translator/testData/dynamic/cases/getByBrackets.kt create mode 100644 js/js.translator/testData/dynamic/cases/identityEquals.kt create mode 100644 js/js.translator/testData/dynamic/cases/in.kt create mode 100644 js/js.translator/testData/dynamic/cases/incrementAndDecrement.kt create mode 100644 js/js.translator/testData/dynamic/cases/infixCall.kt create mode 100644 js/js.translator/testData/dynamic/cases/invoke.kt create mode 100644 js/js.translator/testData/dynamic/cases/is.js create mode 100644 js/js.translator/testData/dynamic/cases/is.kt create mode 100644 js/js.translator/testData/dynamic/cases/isJsPrimitiveType.kt create mode 100644 js/js.translator/testData/dynamic/cases/operationsWithAssignment.kt create mode 100644 js/js.translator/testData/dynamic/cases/propertyAccess.kt create mode 100644 js/js.translator/testData/dynamic/cases/setByBrackets.kt create mode 100644 js/js.translator/testData/dynamic/cases/unaryOperations.kt diff --git a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt index 6ce34f21539..117927f25d8 100644 --- a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt @@ -134,6 +134,7 @@ import org.jetbrains.jet.renderer.AbstractDescriptorRendererTest import org.jetbrains.jet.types.AbstractJetTypeBindingTest import org.jetbrains.jet.plugin.debugger.evaluate.AbstractCodeFragmentCompletionHandlerTest import org.jetbrains.jet.plugin.coverage.AbstractKotlinCoverageOutputFilesTest +import org.jetbrains.k2js.test.semantics.AbstractDynamicTest fun main(args: Array) { System.setProperty("java.awt.headless", "true") @@ -681,6 +682,10 @@ fun main(args: Array) { testClass(javaClass()) { model("reservedWords/cases") } + + testClass(javaClass()) { + model("dynamic/cases") + } } testGroup("js/js.tests/test", "compiler/testData") { diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/AbstractDynamicTest.kt b/js/js.tests/test/org/jetbrains/k2js/test/semantics/AbstractDynamicTest.kt new file mode 100644 index 00000000000..d1cd8f58820 --- /dev/null +++ b/js/js.tests/test/org/jetbrains/k2js/test/semantics/AbstractDynamicTest.kt @@ -0,0 +1,21 @@ +/* + * 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.test.SingleFileTranslationTest + +public abstract class AbstractDynamicTest : SingleFileTranslationTest("dynamic/") \ No newline at end of file diff --git a/js/js.tests/test/org/jetbrains/k2js/test/semantics/DynamicTestGenerated.java b/js/js.tests/test/org/jetbrains/k2js/test/semantics/DynamicTestGenerated.java new file mode 100644 index 00000000000..2cc936e50f2 --- /dev/null +++ b/js/js.tests/test/org/jetbrains/k2js/test/semantics/DynamicTestGenerated.java @@ -0,0 +1,146 @@ +/* + * 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 com.intellij.testFramework.TestDataPath; +import org.jetbrains.jet.JUnit3RunnerWithInners; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.test.InnerTestClasses; +import org.jetbrains.jet.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("js/js.translator/testData/dynamic/cases") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class DynamicTestGenerated extends AbstractDynamicTest { + public void testAllFilesPresentInCases() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("js/js.translator/testData/dynamic/cases"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("binaryOperations.kt") + public void testBinaryOperations() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/binaryOperations.kt"); + doTest(fileName); + } + + @TestMetadata("callGetMethod.kt") + public void testCallGetMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/callGetMethod.kt"); + doTest(fileName); + } + + @TestMetadata("callMethods.kt") + public void testCallMethods() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/callMethods.kt"); + doTest(fileName); + } + + @TestMetadata("callSetMethod.kt") + public void testCallSetMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/callSetMethod.kt"); + doTest(fileName); + } + + @TestMetadata("compareTo.kt") + public void testCompareTo() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/compareTo.kt"); + doTest(fileName); + } + + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/equals.kt"); + doTest(fileName); + } + + @TestMetadata("getByBrackets.kt") + public void testGetByBrackets() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/getByBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("identityEquals.kt") + public void testIdentityEquals() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/identityEquals.kt"); + doTest(fileName); + } + + @TestMetadata("in.kt") + public void testIn() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/in.kt"); + doTest(fileName); + } + + @TestMetadata("incrementAndDecrement.kt") + public void testIncrementAndDecrement() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/incrementAndDecrement.kt"); + doTest(fileName); + } + + @TestMetadata("infixCall.kt") + public void testInfixCall() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/infixCall.kt"); + doTest(fileName); + } + + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/invoke.kt"); + doTest(fileName); + } + + @TestMetadata("is.kt") + public void testIs() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/is.kt"); + doTest(fileName); + } + + @TestMetadata("isJsPrimitiveType.kt") + public void testIsJsPrimitiveType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/isJsPrimitiveType.kt"); + doTest(fileName); + } + + @TestMetadata("operationsWithAssignment.kt") + public void testOperationsWithAssignment() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/operationsWithAssignment.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAccess.kt") + public void testPropertyAccess() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/propertyAccess.kt"); + doTest(fileName); + } + + @TestMetadata("setByBrackets.kt") + public void testSetByBrackets() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/setByBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("unaryOperations.kt") + public void testUnaryOperations() throws Exception { + String fileName = JetTestUtils.navigationMetadata("js/js.translator/testData/dynamic/cases/unaryOperations.kt"); + doTest(fileName); + } +} diff --git a/js/js.translator/testData/_commonFiles/asserts.kt b/js/js.translator/testData/_commonFiles/asserts.kt index 1a214268faa..4cddfa068ba 100644 --- a/js/js.translator/testData/_commonFiles/asserts.kt +++ b/js/js.translator/testData/_commonFiles/asserts.kt @@ -17,3 +17,5 @@ fun assertNotEquals(illegal: T, actual: T, message: String? = null) { } fun assertTrue(actual: Boolean, message: String? = null) = assertEquals(true, actual, message) + +fun assertFalse(actual: Boolean, message: String? = null) = assertEquals(false, actual, message) diff --git a/js/js.translator/testData/dynamic/_commonFiles/common.js b/js/js.translator/testData/dynamic/_commonFiles/common.js new file mode 100644 index 00000000000..2668af35c1b --- /dev/null +++ b/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) + ")" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/_commonFiles/common.kt b/js/js.translator/testData/dynamic/_commonFiles/common.kt new file mode 100644 index 00000000000..859cad59f65 --- /dev/null +++ b/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()) +} diff --git a/js/js.translator/testData/dynamic/cases/binaryOperations.kt b/js/js.translator/testData/dynamic/cases/binaryOperations.kt new file mode 100644 index 00000000000..a58699de24a --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/dynamic/cases/callGetMethod.kt b/js/js.translator/testData/dynamic/cases/callGetMethod.kt new file mode 100644 index 00000000000..e2350d060d2 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/callMethods.kt b/js/js.translator/testData/dynamic/cases/callMethods.kt new file mode 100644 index 00000000000..c92fbd739f9 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/callSetMethod.kt b/js/js.translator/testData/dynamic/cases/callSetMethod.kt new file mode 100644 index 00000000000..524bd5007e4 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/compareTo.kt b/js/js.translator/testData/dynamic/cases/compareTo.kt new file mode 100644 index 00000000000..9b0e3286bc6 --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/dynamic/cases/equals.kt b/js/js.translator/testData/dynamic/cases/equals.kt new file mode 100644 index 00000000000..06b91799211 --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/dynamic/cases/getByBrackets.kt b/js/js.translator/testData/dynamic/cases/getByBrackets.kt new file mode 100644 index 00000000000..a936c9266dd --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/identityEquals.kt b/js/js.translator/testData/dynamic/cases/identityEquals.kt new file mode 100644 index 00000000000..12b38f9c519 --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/dynamic/cases/in.kt b/js/js.translator/testData/dynamic/cases/in.kt new file mode 100644 index 00000000000..1e70f7be96f --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/incrementAndDecrement.kt b/js/js.translator/testData/dynamic/cases/incrementAndDecrement.kt new file mode 100644 index 00000000000..1f47a9e628b --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/dynamic/cases/infixCall.kt b/js/js.translator/testData/dynamic/cases/infixCall.kt new file mode 100644 index 00000000000..e42b07fe819 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/invoke.kt b/js/js.translator/testData/dynamic/cases/invoke.kt new file mode 100644 index 00000000000..e58cdd2069e --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/is.js b/js/js.translator/testData/dynamic/cases/is.js new file mode 100644 index 00000000000..28902248eb3 --- /dev/null +++ b/js/js.translator/testData/dynamic/cases/is.js @@ -0,0 +1,2 @@ +function B() { +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/is.kt b/js/js.translator/testData/dynamic/cases/is.kt new file mode 100644 index 00000000000..be53434b22c --- /dev/null +++ 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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/isJsPrimitiveType.kt b/js/js.translator/testData/dynamic/cases/isJsPrimitiveType.kt new file mode 100644 index 00000000000..9eb68d694ca --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/operationsWithAssignment.kt b/js/js.translator/testData/dynamic/cases/operationsWithAssignment.kt new file mode 100644 index 00000000000..d1ca260fcb8 --- /dev/null +++ b/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" +} diff --git a/js/js.translator/testData/dynamic/cases/propertyAccess.kt b/js/js.translator/testData/dynamic/cases/propertyAccess.kt new file mode 100644 index 00000000000..67c0bfcae94 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/setByBrackets.kt b/js/js.translator/testData/dynamic/cases/setByBrackets.kt new file mode 100644 index 00000000000..0f4cbacee02 --- /dev/null +++ b/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" +} \ No newline at end of file diff --git a/js/js.translator/testData/dynamic/cases/unaryOperations.kt b/js/js.translator/testData/dynamic/cases/unaryOperations.kt new file mode 100644 index 00000000000..f796b5f8bfb --- /dev/null +++ b/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" +}