Cleanup deprecated symbol usages in testData

2016-01-16 20:10:40 +03:00
parent eefbd72a64
commit 25c4453dc5
403 changed files with 933 additions and 921 deletions
@@ -11,13 +11,13 @@ fun box(): String {
    setD.add(Holder(Dat("a", "b")))
    setD.add(Holder(Dat("a", "b")))
    setD.add(Holder(Dat("a", "b")))
-    assertEquals(1, setD.size())
+    assertEquals(1, setD.size)

    val setO = java.util.HashSet<Holder<Obj>>()
    setO.add(Holder(Obj("a", "b")))
    setO.add(Holder(Obj("a", "b")))
    setO.add(Holder(Obj("a", "b")))
-    assertEquals(3, setO.size())
+    assertEquals(3, setO.size)

    return "OK"
 }
@@ -27,7 +27,7 @@ fun box(): String {
    if (!ok2.identityEquals(ok)) return "ok2 not identity equal ok"


-    if (EmptyEnum.values().size() != 0) return "EmptyEnum.values().size != 0"
+    if (EmptyEnum.values().size != 0) return "EmptyEnum.values().size != 0"

    if (A.values() != arrayOf(A.a, A.b, A.c)) return "Wrong A.values(): " + A.values().toString()

@@ -21,5 +21,5 @@ fun box(): String {
    v1.add("foo")
    v2.add("bar")
    val v3 = v1 + v2
-    return if (v3.contents.size() == 2) "OK" else "fail"
+    return if (v3.contents.size == 2) "OK" else "fail"
 }
@@ -23,5 +23,5 @@ fun box(): String {
    val v3 = v1
    v2.add("bar")
    v1 += v2
-    return if (v1.contents.size() == 2 && v3.contents.size() == 2) "OK" else "fail"
+    return if (v1.contents.size == 2 && v3.contents.size == 2) "OK" else "fail"
 }
@@ -26,5 +26,5 @@ fun box(): String {
    val v3 = v1
    v2.add("bar")
    v1 += v2
-    return if (v1.contents.size() == 2 && v3.contents.size() == 1) "OK" else "fail"
+    return if (v1.contents.size == 2 && v3.contents.size == 1) "OK" else "fail"
 }
@@ -10,7 +10,7 @@ class ArrayWrapper<T>() {
    operator fun unaryMinus(): ArrayWrapper<T> {
        val result = ArrayWrapper<T>()
        result.contents.addAll(contents)
-        var i = contents.size();
+        var i = contents.size;
        for (a in contents) {
            result.contents[--i] = a;
        }
@@ -15,6 +15,6 @@ class World() {

 fun box(): String {
    val w = World()
-    if (w.items.size() != 1) return "fail"
+    if (w.items.size != 1) return "fail"
    return "OK"
 }
@@ -1,7 +1,7 @@
 class Outer(val foo: StringBuilder) {
    class Inner() {
        fun len(): Int {
-            return foo.length()
+            return foo.length
        }
    }

@@ -8,7 +8,7 @@ fun <T> bar(s: String, value: T): T {
 }

 fun <T> baz(vararg args: T): String {
-    return "baz: ${args.size()}"
+    return "baz: ${args.size}"
 }

 fun <T> idVarArg(vararg a: T) = a
@@ -19,7 +19,7 @@ class C {
        var data = arrayOf(T(3), T(1), T(2))
        override fun hasNext(): Boolean {
            log += "C.hasNext();"
-            return i < data.size()
+            return i < data.size
        }

        override fun next(): T {
@@ -142,7 +142,7 @@ val CALEE_NAME = RegExp("""\b\w*(baz[^(]*)""")
 fun Function0<Unit>.extractNames(): Array<String> {
    val names = CALEE_NAME.exec(this.toString())

-    if (names == null || names.size() != 2) {
+    if (names == null || names.size != 2) {
        throw Exception("Cannot extract function name, $names for actual = \"$this\"")
    }

@@ -39,7 +39,7 @@ val CALEE_NAME = RegExp("""((?:equals|hashCode|toString)[^(]*)""")
 fun <T> Function0<T>.extractNames(): Array<String> {
    val names = CALEE_NAME.exec(this.toString())

-    if (names == null || names.size() != 2) {
+    if (names == null || names.size != 2) {
        throw Exception("Cannot extract function name, $names for actual = \"$this\"")
    }

@@ -1,7 +1,7 @@
 package foo

 fun testSize(expectedSize: Int, vararg i: Int): Boolean {
-    return (i.size() == expectedSize)
+    return (i.size == expectedSize)
 }

 fun testSum(expectedSum: Int, vararg i: Int): Boolean {
@@ -17,7 +17,7 @@ fun testSpreadOperator(vararg args: Int): Boolean {
    var sum = 0;
    for (a in args) sum += a

-    return testSize(args.size(), *args) && testSum(sum, *args)
+    return testSize(args.size, *args) && testSum(sum, *args)
 }

 class Bar(val size: Int, val sum: Int) {
@@ -74,23 +74,23 @@ fun box(): String {
    if (!spreadInObjectMethodCall(2, 3, 1, 2))
        return "failed when call method of object using spread operator"

-    if (!testVarargWithFunLit(1, 2, 3) { args -> args.size() == 3 })
+    if (!testVarargWithFunLit(1, 2, 3) { args -> args.size == 3 })
        return "failed when call function with vararg and fun literal"

    val a = arrayOf(1, 2, 3)
    val b = arrayOf(4, 5)

-    assertEquals(5, arrayOf(*a, *b).size())
-    assertEquals(8, arrayOf(10, *a, 20,  *b, 30).size())
+    assertEquals(5, arrayOf(*a, *b).size)
+    assertEquals(8, arrayOf(10, *a, 20,  *b, 30).size)

-    assertEquals(5, idVarArgs(*a, *b).size())
-    assertEquals(8, idVarArgs(10, *a, 20,  *b, 30).size())
+    assertEquals(5, idVarArgs(*a, *b).size)
+    assertEquals(8, idVarArgs(10, *a, 20,  *b, 30).size)

-    assertEquals(9, arrayOf(1, *a, *a, 1, 2).size())
-    assertEquals(9, idVarArgs(1, *a, *a, 1, 2).size())
+    assertEquals(9, arrayOf(1, *a, *a, 1, 2).size)
+    assertEquals(9, idVarArgs(1, *a, *a, 1, 2).size)

-    assertEquals(9, arrayOf(1, *a, *arrayOf(1, 2, 3), 1, 2).size())
-    assertEquals(9, idVarArgs(1, *a, *arrayOf(1, 2, 3), 1, 2).size())
+    assertEquals(9, arrayOf(1, *a, *arrayOf(1, 2, 3), 1, 2).size)
+    assertEquals(9, idVarArgs(1, *a, *arrayOf(1, 2, 3), 1, 2).size)

    assertEquals(90, sumFunValuesOnParameters(1, 2, 3, 4, 5, 6, 7, 8, 9) { 2*it })
    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5, 6, 7, 8, 9)) { 2*it })
@@ -99,9 +99,9 @@ fun box(): String {
    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5), *intArrayOf(6, 7, 8, 9)) { 2*it })
    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4), 5, 6, *intArrayOf(7, 8, 9)) { 2*it })

-    assertEquals(2, idArrayVarArg(arrayOf(1), *arrayOf(arrayOf(2, 3, 4))).size())
-    assertEquals(3, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6))).size())
-    assertEquals(6, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6)), arrayOf(7), *arrayOf(arrayOf(8, 9), arrayOf(10, 11))).size())
+    assertEquals(2, idArrayVarArg(arrayOf(1), *arrayOf(arrayOf(2, 3, 4))).size)
+    assertEquals(3, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6))).size)
+    assertEquals(6, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6)), arrayOf(7), *arrayOf(arrayOf(8, 9), arrayOf(10, 11))).size)

    return "OK"
 }
@@ -7,8 +7,8 @@
 package foo

 fun firstNotNullLen(s1 : String?, s2 : String?, s3 : String?) : Int {
-    val len = (s1?.length() ?: s2?.length()) ?:
-                (s2?.length() ?: s3?.length()) ?:
+    val len = (s1?.length ?: s2?.length) ?:
+                (s2?.length ?: s3?.length) ?:
                    return 0
    return len
 }
@@ -8,11 +8,11 @@ package foo

 fun stringLen(s : String?) : Int {
    val s1 : String = s ?: return 0
-    return s1.length()
+    return s1.length
 }

 fun stringReturnInLeftLen(s : String?) : Int {
-    val s1 = (if (s != null) { return s.length() } else { null }) ?: return 0
+    val s1 = (if (s != null) { return s.length } else { null }) ?: return 0
 }

 fun box(): String {
@@ -22,7 +22,7 @@ fun assertEquals(expected: Any, actual: Any, s: CharSequence, whatTested: String

 fun testString(s: String, expectedSize: Int, indexOfB: Int) {
    assertEquals(expectedSize, s.size, s, "size")
-    assertEquals(expectedSize, s.length(), s, "length()")
+    assertEquals(expectedSize, s.length, s, "length")
    assertEquals(expectedSize == 0, s.isEmpty(), s, "isEmpty()")
    assertEquals(expectedSize != 0, s.startsWith(startsWithParam), s, "startsWith(\"$startsWithParam\")")
    assertEquals(expectedSize != 0, s.endsWith(endsWithParam), s, "endsWith(\"$endsWithParam\")")
@@ -35,7 +35,7 @@ fun testString(s: String, expectedSize: Int, indexOfB: Int) {

 fun testCharSequence(s: CharSequence, expectedSize: Int) {
    assertEquals(expectedSize, s.size, s, "size")
-    assertEquals(expectedSize, s.length(), s, "length()")
+    assertEquals(expectedSize, s.length, s, "length")
    assertEquals(expectedSize == 0, s.isEmpty(), s, "isEmpty()")
 }

@@ -3,7 +3,7 @@ package foo
 fun box(): String {
    val kotlin: String = "kotlin"

-    if (kotlin.subSequence(0, kotlin.length()) != kotlin) return "Fail 0"
+    if (kotlin.subSequence(0, kotlin.length) != kotlin) return "Fail 0"

    val kot: CharSequence = kotlin.subSequence(0, 3)
    if (kot.toString() != "kot") return "Fail 1: $kot"
@@ -7,7 +7,7 @@ fun box(): String {
    try {
        throw Exception("Exception")
    } catch (e: Throwable) {
-        s = "Throwable:" + e.getMessage()!!
+        s = "Throwable:" + e.message!!
    }
    assertEquals("Throwable:Exception", s)

@@ -15,7 +15,7 @@ fun box(): String {
    try {
        throw Exception("Exception")
    } catch (e: Exception) {
-        s = "Exception:" + e.getMessage()!!
+        s = "Exception:" + e.message!!
    }
    assertEquals("Exception:Exception", s)

@@ -23,7 +23,7 @@ fun box(): String {
    try {
        throw RuntimeException("RuntimeException")
    } catch (e: Exception) {
-        s = "Exception:" + e.getMessage()!!
+        s = "Exception:" + e.message!!
    }
    assertEquals("Exception:RuntimeException", s)

@@ -31,7 +31,7 @@ fun box(): String {
    try {
        throw NullPointerException("NullPointerException")
    } catch (e: Exception) {
-        s = "Exception:" + e.getMessage()!!
+        s = "Exception:" + e.message!!
    }
    assertEquals("Exception:NullPointerException", s)

@@ -39,18 +39,18 @@ fun box(): String {
    try {
        throw IndexOutOfBoundsException("IndexOutOfBoundsException")
    } catch (e: NullPointerException) {
-        s = "NullPointerException:" + e.getMessage()!!
+        s = "NullPointerException:" + e.message!!
    } catch (e: RuntimeException) {
-        s = "RuntimeException:" + e.getMessage()!!
+        s = "RuntimeException:" + e.message!!
    } catch (e: Exception) {
-        s = "Exception:" + e.getMessage()!!
+        s = "Exception:" + e.message!!
    }
    assertEquals("RuntimeException:IndexOutOfBoundsException", s)

    try {
        throw RuntimeException()
    } catch (e: Exception) {
-        assertEquals(null, e.getMessage())
+        assertEquals(null, e.message)
    }

   return "OK"
@@ -20,5 +20,5 @@ fun box(): String {


    val m: ArrayList<Int> = list.findAll<Int>({ name: Int -> name < 4 })
-    return if (m.size() == 2) "OK" else "fail"
+    return if (m.size == 2) "OK" else "fail"
 }
@@ -1,7 +1,7 @@
 package foo

 val String.prop: Int
-    get() = length()
+    get() = length

 val Int.quadruple: Int
    get() = this * 4
@@ -4,7 +4,7 @@ class MyCharIterator : CharIterator() {
    val data = arrayOf('O', 'K')
    var i = 0

-    override fun hasNext(): Boolean = i < data.size()
+    override fun hasNext(): Boolean = i < data.size
    override fun nextChar(): Char = data[i++]
 }

@@ -9,7 +9,7 @@ package foo
 data class PairArray<T, R>(val fst: Array<T>, val snd: Array<R>)

 inline fun moveTo(source: Array<Int>, sink: Array<Int>): PairArray<Int, Int> {
-    val size = source.size()
+    val size = source.size
    for (i in 1..size) {
        val element = source[0]
        source.splice(0, 1)
@@ -44,7 +44,7 @@ abstract class Tag(val name: String) : Element() {

    private fun renderAttributes(): String? {
        val builder = StringBuilder()
-        for (a in attributes.keySet()) {
+        for (a in attributes.keys) {
            builder.append(" $a=\"${attributes[a]}\"")
        }
        return builder.toString()
@@ -44,7 +44,7 @@ abstract class Tag(val name: String) : Element() {

    private fun renderAttributes(): String? {
        val builder = StringBuilder()
-        for (a in attributes.keySet()) {
+        for (a in attributes.keys) {
            builder.append(" $a=\"${attributes[a]}\"")
        }
        return builder.toString()
@@ -7,7 +7,7 @@ package foo

 fun test1(): Int {
    val inlineX = Inline()
-    return inlineX.foo({ z: Int -> "" + z}, 25, { -> this.length() })
+    return inlineX.foo({ z: Int -> "" + z}, 25, { -> this.length })
 }

 fun box(): String {
@@ -64,7 +64,7 @@ fun test3(): Int {
                })
        return res
    } catch (e: RuntimeException) {
-        return e.getMessage()?.toInt2()!!
+        return e.message?.toInt2()!!
    }
 }

@@ -4,7 +4,7 @@ import java.util.AbstractList

 class MyList<T>(vararg val data: T) : AbstractList<T>() {
    override fun get(index: Int) = data[index]
-    override val size: Int get() = data.size()
+    override val size: Int get() = data.size
 }

 fun <T> test(expected: String, list: List<T>) {
@@ -6,5 +6,5 @@ fun box(): Boolean {
    val a = ArrayList<Int>();
    a.add(1)
    a.add(2)
-    return (a.size() == 2) && (a.get(1) == 2) && (a.get(0) == 1);
+    return (a.size == 2) && (a.get(1) == 2) && (a.get(0) == 1);
 }
@@ -7,5 +7,5 @@ fun box(): Boolean {
    a.add(1)
    a.add(2)
    a[1] = 100
-    return (a.size() == 2) && (a[1] == 100) && (a[0] == 1);
+    return (a.size == 2) && (a[1] == 100) && (a[0] == 1);
 }
@@ -4,5 +4,5 @@ import java.util.ArrayList

 fun box(): Boolean {
    val al = ArrayList<Int>(10)
-    return al.size() == 0
+    return al.size == 0
 }
@@ -10,5 +10,5 @@ fun withSideEffect(v: Int): Int {

 fun box(): Boolean {
    val al = ArrayList<Int>(withSideEffect(2))
-    return al.size() == 0 && baz == 2
+    return al.size == 0 && baz == 2
 }
@@ -4,5 +4,5 @@ import java.util.ArrayList;

 fun box(): Boolean {
    val a = ArrayList<Int>();
-    return a.size() == 0;
+    return a.size == 0;
 }
@@ -3,7 +3,7 @@ package foo
 import java.util.ArrayList;

 fun <T> test(list: List<T>, elements: List<T>, expected: List<Int>, method: List<T>.(T) -> Int, methodName: String): String? {
-    for (i in 0..elements.size() - 1) {
+    for (i in 0..elements.size - 1) {
        val actual = list.method(elements[i])
        if (actual != expected[i]) return "$methodName failed when find: ${elements[i]}, expected: ${expected[i]}, actual: $actual"
    }
@@ -12,5 +12,5 @@ fun box(): Boolean {
    for (a in arr) {
        sum += a;
    }
-    return (sum == 55) && (arr.size() == 10)
+    return (sum == 55) && (arr.size == 10)
 }
@@ -10,5 +10,5 @@ fun box(): Boolean {

    val removedElement = arr.removeAt(2)
    val removed = arr.remove(4)
-    return arr.size() == 4 && removedElement == 2 && removed && arr[0] == 0 && arr[1] == 1 && arr[2] == 3 && arr[3] == 5
+    return arr.size == 4 && removedElement == 2 && removed && arr[0] == 0 && arr[1] == 1 && arr[2] == 3 && arr[3] == 5
 }
@@ -4,7 +4,7 @@ import java.util.ArrayList;


 fun <T> test(a: List<T>, b: List<T>, removed: Boolean, expected: List<T>): String? {
-    val t = ArrayList<T>(a.size())
+    val t = ArrayList<T>(a.size)
    t.addAll(a)

    if (t.removeAll(b) != removed) return "$a.removeAll($b) != $removed, result list: $t"
@@ -5,8 +5,8 @@ package foo
 }

 fun <T> assertArrayEquals(expected: Array<T>, actual: Array<T>) {
-    val expectedSize = expected.size()
-    val actualSize = actual.size()
+    val expectedSize = expected.size
+    val actualSize = actual.size

    if (expectedSize != actualSize) {
        throw Exception("expected size -- $expectedSize, actual size -- $actualSize")
@@ -4,18 +4,18 @@ import java.util.HashMap


 operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>> {
-    val entrySet = this.entrySet()
+    val entrySet = this.entries
    return entrySet.iterator()
 }

 /** Returns the key of the entry */
 operator fun <K, V> Map.Entry<K, V>.component1(): K {
-    return getKey()
+    return key
 }

 /** Returns the value of the entry */
 operator fun <K, V> Map.Entry<K, V>.component2(): V {
-    return getValue()
+    return value
 }

 fun box(): String {
@@ -56,7 +56,7 @@ fun testSpreadOperatorWithSureCall(a: Bar?, vararg args: Int): Boolean {

 fun testCallOrder(vararg args: Int) =
        Bar.startNewTest() &&
-        Bar(args.size(), 0).test(1, 1, *args) && Bar(args.size(), 2).test(3, 1, *args) &&
+        Bar(args.size, 0).test(1, 1, *args) && Bar(args.size, 2).test(3, 1, *args) &&
        !Bar.hasOrderProblem

@native
@@ -105,7 +105,7 @@ fun box(): String {
    if (!spreadInPackageMethodCall(2, 1, 2))
        return "failed when call package method using spread operator"

-    if (!(testNativeVarargWithFunLit(1, 2, 3) { args -> args.size() == 3 }))
+    if (!(testNativeVarargWithFunLit(1, 2, 3) { args -> args.size == 3 }))
        return "failed when call native function with vararg and fun literal"

    if (!(testSpreadOperatorWithSafeCall(null, null)))
@@ -141,9 +141,9 @@ fun box(): String {
    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4, 5), *intArrayOf(6, 7, 8, 9)) { 2*it })
    assertEquals(90, sumFunValuesOnParameters(1, 2, *intArrayOf(3, 4), 5, 6, *intArrayOf(7, 8, 9)) { 2*it })

-    assertEquals(2, idArrayVarArg(arrayOf(1), *arrayOf(arrayOf(2, 3, 4))).size())
-    assertEquals(3, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6))).size())
-    assertEquals(6, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6)), arrayOf(7), *arrayOf(arrayOf(8, 9), arrayOf(10, 11))).size())
+    assertEquals(2, idArrayVarArg(arrayOf(1), *arrayOf(arrayOf(2, 3, 4))).size)
+    assertEquals(3, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6))).size)
+    assertEquals(6, idArrayVarArg(arrayOf(1, 2), *arrayOf(arrayOf(3, 4), arrayOf(5, 6)), arrayOf(7), *arrayOf(arrayOf(8, 9), arrayOf(10, 11))).size)

    return "OK"
 }
@@ -5,7 +5,7 @@ fun box(): String {
    val arr = LongArray(2)

    val expected: Long = 0
-    assertEquals(arr.size(), 2)
+    assertEquals(arr.size, 2)
    assertEquals(expected, arr[0])
    assertEquals(expected, arr[1])

@@ -24,5 +24,5 @@ fun box(): String {
    v1.add("foo")
    v2.add("bar")
    v1 += v2
-    return if (v1.contents.size() == 2) "OK" else "fail"
+    return if (v1.contents.size == 2) "OK" else "fail"
 }
@@ -19,5 +19,5 @@ fun box(): Boolean {
    val a = A(v1)
    a += v2

-    return (v1.size() == 2 && v1[0] == "foo" && v1[1] == "bar")
+    return (v1.size == 2 && v1[0] == "foo" && v1[1] == "bar")
 }
@@ -16,5 +16,5 @@ fun box(): Boolean {
    v2.add("bar")
    val v = v1 + v2

-    return (v.size() == 2 && v[0] == "foo" && v[1] == "bar")
+    return (v.size == 2 && v[0] == "foo" && v[1] == "bar")
 }
@@ -9,7 +9,7 @@ fun test(keyword: String, expectedRenamed: Boolean, f: Any) {
    val fs = f.toString().replace("while (false)", "")
    val matches = Regex("[\\w$]*$keyword[\\w_$]*").matchAll(fs).map { it.value }.toList()

-    assertNotEquals(0, matches.size(), "matches is empty for fs = $fs")
+    assertNotEquals(0, matches.size, "matches is empty for fs = $fs")

    val actual = matches.last()

@@ -45,8 +45,8 @@ fun checkHashMap(obj: Any) {
    assertTrue(obj is HashMap<*, *>, "checkHashMap: is HashMap")
    assertTrue(obj is MutableMap<*, *>, "checkHashMap: is MutableMap")
    assertTrue(obj is Map<*, *>, "checkHashMap: is Map")
-    assertTrue((obj as Map<*, *>).values() is Collection, "checkHashMap: values() is Collection")
-    assertTrue((obj as Map<*, *>).keySet() is Set, "checkHashMap: keySet() is Set")
+    assertTrue((obj as Map<*, *>).values is Collection, "checkHashMap: values is Collection")
+    assertTrue((obj as Map<*, *>).keys is Set, "checkHashMap: keys is Set")
 }

 fun checkLinkedHashMap(obj: Any) {
@@ -12,7 +12,7 @@ fun box(): String {
    assertTrue((stdlib_emptyListClass() as Any) !is ArrayList<*>, "stdlib_emptyListClass() !is ArrayList<*>")

    assertTrue(stdlib_emptyListClass().isEmpty(), "stdlib_emptyListClass().isEmpty()")
-    assertTrue(stdlib_emptyListClass().size() == 0, "stdlib_emptyListClass().size() == 0")
+    assertTrue(stdlib_emptyListClass().size == 0, "stdlib_emptyListClass().size == 0")

    return "OK"
 }
@@ -9,75 +9,75 @@ fun box(): String {

    val mapWithIntKeys = HashMap<Int, Int>()
    mapWithIntKeys[1] = 1
-    assertEquals("number", jsTypeOf (mapWithIntKeys.keySet().iterator().next()), "mapWithIntKeys")
+    assertEquals("number", jsTypeOf (mapWithIntKeys.keys.iterator().next()), "mapWithIntKeys")

    val mapWithShortKeys = HashMap<Short, Int>()
    mapWithShortKeys[1.toShort()] = 1
-    assertEquals("number", jsTypeOf (mapWithShortKeys.keySet().iterator().next()), "mapWithShortKeys")
+    assertEquals("number", jsTypeOf (mapWithShortKeys.keys.iterator().next()), "mapWithShortKeys")

    val mapWithByteKeys = HashMap<Byte, Int>()
    mapWithByteKeys[1.toByte()] = 1
-    assertEquals("number", jsTypeOf (mapWithByteKeys.keySet().iterator().next()), "mapWithByteKeys")
+    assertEquals("number", jsTypeOf (mapWithByteKeys.keys.iterator().next()), "mapWithByteKeys")

    val mapWithDoubleKeys = HashMap<Double, Int>()
    mapWithDoubleKeys[1.0] = 1
-    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keySet().iterator().next()), "mapWithDoubleKeys")
+    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keys.iterator().next()), "mapWithDoubleKeys")

    mapWithDoubleKeys.clear()
    var dNaN = 0.0 / 0.0
    mapWithDoubleKeys[dNaN] = 100
    assertEquals(100, mapWithDoubleKeys[dNaN])
-    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keySet().iterator().next()), "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.keySet().iterator().next()), "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.keySet().iterator().next()), "dNegativeInfinity")
+    assertEquals("number", jsTypeOf (mapWithDoubleKeys.keys.iterator().next()), "dNegativeInfinity")

    val mapWithFloatKeys = HashMap<Float, Int>()
    mapWithFloatKeys[1.0f] = 1
-    assertEquals("number", jsTypeOf (mapWithFloatKeys.keySet().iterator().next()), "mapWithFloatKeys")
+    assertEquals("number", jsTypeOf (mapWithFloatKeys.keys.iterator().next()), "mapWithFloatKeys")

    mapWithFloatKeys.clear()
    var fNaN: Float = 0.0f / 0.0f
    mapWithFloatKeys[fNaN] = 100
    assertEquals(100, mapWithFloatKeys[fNaN])
-    assertEquals("number", jsTypeOf (mapWithFloatKeys.keySet().iterator().next()), "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.keySet().iterator().next()), "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.keySet().iterator().next()), "fNegativeInfinity")
+    assertEquals("number", jsTypeOf (mapWithFloatKeys.keys.iterator().next()), "fNegativeInfinity")

    val mapWithCharKeys = HashMap<Char, Int>()
    mapWithCharKeys['A'] = 1
-    assertEquals("number", jsTypeOf (mapWithCharKeys.keySet().iterator().next()), "mapWithCharKeys")
+    assertEquals("number", jsTypeOf (mapWithCharKeys.keys.iterator().next()), "mapWithCharKeys")

    val mapWithLongKeys = HashMap<Long, Int>()
    mapWithLongKeys[1L] = 1
-    assertEquals("number", jsTypeOf (mapWithLongKeys.keySet().iterator().next()), "mapWithLongKeys")
+    assertEquals("number", jsTypeOf (mapWithLongKeys.keys.iterator().next()), "mapWithLongKeys")

    val mapWithBooleanKeys = HashMap<Boolean, Int>()
    mapWithBooleanKeys[true] = 1
-    assertEquals("boolean", jsTypeOf (mapWithBooleanKeys.keySet().iterator().next()), "mapWithBooleanKeys")
+    assertEquals("boolean", jsTypeOf (mapWithBooleanKeys.keys.iterator().next()), "mapWithBooleanKeys")

    val mapWithStringKeys = HashMap<String, Int>()
    mapWithStringKeys["key"] = 1
-    assertEquals("string", jsTypeOf (mapWithStringKeys.keySet().iterator().next()), "mapWithStringKeys")
+    assertEquals("string", jsTypeOf (mapWithStringKeys.keys.iterator().next()), "mapWithStringKeys")

    return "OK"
 }
@@ -5,6 +5,6 @@ fun main(args: Array<String>) {

 fun getStringLength(obj: Any): Int? {
    if (obj is String)
-        return obj.length() // no cast to String is needed
+        return obj.length // no cast to String is needed
    return null
 }
@@ -1,5 +1,5 @@
 fun main(args: Array<String>) {
-    val language = if (args.size() == 0) "EN" else args[0]
+    val language = if (args.size == 0) "EN" else args[0]
    println(when (language) {
                "EN" -> "Hello!"
                "FR" -> "Salut!"
@@ -10,7 +10,7 @@ fun myParseInt(str: String): Int? {
 }

 fun main(args: Array<String>) {
-    if (args.size() < 2) {
+    if (args.size < 2) {
        print("No number supplied");
    }
    else {
@@ -19,8 +19,8 @@ fun main(args: Array<String>) {
    array.add("bbb")
    array.add("ccc")

-    if (x !in 0..array.size())
-        println("Out: array has only ${array.size()} elements. x = ${x}")
+    if (x !in 0..array.size)
+        println("Out: array has only ${array.size} elements. x = ${x}")

    //Check if a collection contains an object:
    if ("aaa" in array) // collection.contains(obj) is called
@@ -1,5 +1,5 @@
 fun main(args: Array<String>) {
    var i = 0
-    while (i < args.size())
+    while (i < args.size)
        println(args[i++])
 }
@@ -72,4 +72,4 @@ fun bottlesOfBeer(count: Int): String =
 // From the std package
 // This is an extension property, i.e. a property that is defined for the
 // type Array<T>, but does not sit inside the class Array
-fun <T> Array<T>.isEmpty() = size() == 0
+fun <T> Array<T>.isEmpty() = size == 0
@@ -81,7 +81,7 @@ abstract class Tag(val name: String) : Element() {

    private fun renderAttributes(): String? {
        val builder = StringBuilder()
-        for (a in attributes.keySet()) {
+        for (a in attributes.keys) {
            builder.append(" $a=\"${attributes[a]}\"")
        }
        return builder.toString()
@@ -124,15 +124,15 @@ fun makeField(s: String): Field {
    val lines: List<String> = s.split("\n")

    val w = Collections.max<String>(lines.toList(), comparator<String> { o1, o2 ->
-        val l1: Int = o1.length()
-        val l2 = o2.length()
+        val l1: Int = o1.length
+        val l2 = o2.length
        l1 - l2
    })!!
-    val data = Array(lines.size()) { Array(w.length()) { false } }
+    val data = Array(lines.size) { Array(w.length) { false } }

    // workaround
    for (i in data.indices) {
-        data[i] = Array(w.length()) { false }
+        data[i] = Array(w.length) { false }
        for (j in data[i].indices)
            data[i][j] = false
    }
@@ -144,5 +144,5 @@ fun makeField(s: String): Field {
        }
    }

-    return Field(w.length(), lines.size()) { i, j -> data[i][j] }
+    return Field(w.length, lines.size) { i, j -> data[i][j] }
 }