Recover test for mutable List variable and move it to ListSpecificTests

libraries/stdlib/test/collections/ListSpecificTest.kt

@@ -40,4 +40,17 @@ class ListSpecificTest {
         assertEquals("bar", data.last)
         assertEquals(1, data.lastIndex)
     }
+
+    Test fun mutableList() {
+        val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
+
+        var list = arrayListOf<String>()
+        for (e in map) {
+            list += e.getKey()
+            list += e.getValue()
+        }
+
+        assertEquals(6, list.size())
+        assertEquals("beverage,beer,location,Mells,name,James", list.makeString(","))
+    }
 }

libraries/stdlib/test/collections/MapTest.kt

@@ -9,60 +9,55 @@ class MapTest {
 
     test fun getOrElse() {
         val data = hashMapOf<String, Int>()
-        val a = data.getOrElse("foo"){2}
+        val a = data.getOrElse("foo") { 2 }
         assertEquals(2, a)
 
-        val b = data.getOrElse("foo"){3}
+        val b = data.getOrElse("foo") { 3 }
         assertEquals(3, b)
         assertEquals(0, data.size())
 
         val empty = hashMapOf<String, Int?>()
-        val c = empty.getOrElse("") {null}
+        val c = empty.getOrElse("") { null }
         assertEquals(null, c)
     }
 
     test fun getOrPut() {
         val data = hashMapOf<String, Int>()
-        val a = data.getOrPut("foo"){2}
+        val a = data.getOrPut("foo") { 2 }
         assertEquals(2, a)
 
-        val b = data.getOrPut("foo"){3}
+        val b = data.getOrPut("foo") { 3 }
         assertEquals(2, b)
 
         assertEquals(1, data.size())
 
         val empty = hashMapOf<String, Int?>()
-        val c = empty.getOrPut("") {null}
+        val c = empty.getOrPut("") { null }
         assertEquals(null, c)
     }
 
     test fun sizeAndEmpty() {
         val data = hashMapOf<String, Int>()
-        assertTrue{ data.empty }
+        assertTrue { data.empty }
         assertEquals(data.size, 0)
     }
 
     test fun setViaIndexOperators() {
         val map = hashMapOf<String, String>()
-        assertTrue{ map.empty }
+        assertTrue { map.empty }
         assertEquals(map.size, 0)
 
         map["name"] = "James"
 
-        assertTrue{ !map.empty }
+        assertTrue { !map.empty }
         assertEquals(map.size(), 1)
         assertEquals("James", map["name"])
     }
-
+   
     test fun iterate() {
-        val map = TreeMap<String, String>()
+        val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
-        map["beverage"] = "beer"
-        map["location"] = "Mells"
-        map["name"] = "James"
-
         val list = arrayListOf<String>()
         for (e in map) {
-            println("key = ${e.getKey()}, value = ${e.getValue()}")
             list.add(e.getKey())
             list.add(e.getValue())
         }
@@ -72,14 +67,9 @@ class MapTest {
     }
 
     test fun iterateWithProperties() {
-        val map = TreeMap<String, String>()
+        val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
-        map["beverage"] = "beer"
-        map["location"] = "Mells"
-        map["name"] = "James"
-
         val list = arrayListOf<String>()
         for (e in map) {
-            println("key = ${e.key}, value = ${e.value}")
             list.add(e.key)
             list.add(e.value)
         }
@@ -89,14 +79,9 @@ class MapTest {
     }
 
     test fun iterateWithExtraction() {
-        val map = TreeMap<String, String>()
+        val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
-        map["beverage"] = "beer"
-        map["location"] = "Mells"
-        map["name"] = "James"
-
         val list = arrayListOf<String>()
         for ((key, value) in map) {
-            println("key = ${key}, value = ${value}")
             list.add(key)
             list.add(value)
         }
@@ -112,32 +97,34 @@ class MapTest {
     }
 
     test fun map() {
-        val m1 = TreeMap<String, String>()
+        val m1 = mapOf("beverage" to "beer", "location" to "Mells")
-        m1["beverage"] = "beer"
+        val list = m1.map { it.value + " rocks" }
-        m1["location"] = "Mells"
-
-        val list = m1.map{ it.value + " rocks" }
 
         println("Got new list $list")
         assertEquals(arrayListOf("beer rocks", "Mells rocks"), list)
     }
 
     test fun mapValues() {
-        val m1 = TreeMap<String, String>()
+        val m1 = mapOf("beverage" to "beer", "location" to "Mells")
-        m1["beverage"] = "beer"
+        val m2 = m1.mapValues { it.value + "2" }
-        m1["location"] = "Mells"
-
-        val m2 = m1.mapValues{ it.value + "2" }
 
         assertEquals("beer2", m2["beverage"])
         assertEquals("Mells2", m2["location"])
     }
 
+    test fun mapKeys() {
+        val m1 = mapOf("beverage" to "beer", "location" to "Mells")
+        val m2 = m1.mapKeys { it.key + "2" }
+
+        assertEquals("beer", m2["beverage2"])
+        assertEquals("Mells", m2["location2"])
+    }
+
     test fun createUsingPairs() {
         val map = hashMapOf(Pair("a", 1), Pair("b", 2))
         assertEquals(2, map.size)
-        assertEquals(1, map.get("a"))
+        assertEquals(1, map["a"])
-        assertEquals(2, map.get("b"))
+        assertEquals(2, map["b"])
     }
 
     test fun createFromIterable() {
@@ -150,32 +137,32 @@ class MapTest {
     test fun createUsingTo() {
         val map = hashMapOf("a" to 1, "b" to 2)
         assertEquals(2, map.size)
-        assertEquals(1, map.get("a"))
+        assertEquals(1, map["a"])
-        assertEquals(2, map.get("b"))
+        assertEquals(2, map["b"])
     }
 
     test fun createLinkedMap() {
         val map = linkedMapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
-        assertEquals(1, map.get("a"))
+        assertEquals(1, map["a"])
-        assertEquals(2, map.get("b"))
+        assertEquals(2, map["b"])
-        assertEquals(3, map.get("c"))
+        assertEquals(3, map["c"])
         assertEquals(arrayListOf("c", "b", "a"), map.keySet().toList())
     }
 
     test fun createSortedMap() {
         val map = sortedMapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
-        assertEquals(1, map.get("a"))
+        assertEquals(1, map["a"])
-        assertEquals(2, map.get("b"))
+        assertEquals(2, map["b"])
-        assertEquals(3, map.get("c"))
+        assertEquals(3, map["c"])
         assertEquals(arrayListOf("a", "b", "c"), map.keySet().toList())
     }
 
     test fun toSortedMap() {
-        val map = hashMapOf<String,Int>(Pair("c", 3), Pair("b", 2), Pair("a", 1))
+        val map = hashMapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
-        val sorted = map.toSortedMap<String,Int>()
+        val sorted = map.toSortedMap<String, Int>()
-        assertEquals(1, sorted.get("a"))
+        assertEquals(1, sorted["a"])
-        assertEquals(2, sorted.get("b"))
+        assertEquals(2, sorted["b"])
-        assertEquals(3, sorted.get("c"))
+        assertEquals(3, sorted["c"])
         assertEquals(arrayListOf("a", "b", "c"), sorted.keySet().toList())
     }
 
@@ -187,34 +174,11 @@ class MapTest {
         }
         val sorted = map.toSortedMap(c)
         assertEquals(arrayListOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
-        assertEquals(1, sorted.get("abc"))
+        assertEquals(1, sorted["abc"])
-        assertEquals(2, sorted.get("bc"))
+        assertEquals(2, sorted["bc"])
-        assertEquals(3, sorted.get("c"))
+        assertEquals(3, sorted["c"])
     }
 
-    /**
-    TODO
-    test case for http://youtrack.jetbrains.com/issue/KT-1773
-
-    test fun compilerBug() {
-        val map = TreeMap<String, String>()
-        map["beverage"] = "beer"
-        map["location"] = "Mells"
-        map["name"] = "James"
-
-        var list = arrayListOf<String>()
-        for (e in map) {
-            println("key = ${e.getKey()}, value = ${e.getValue()}")
-            list += e.getKey()
-            list += e.getValue()
-        }
-
-        assertEquals(6, list.size())
-        assertEquals("beverage,beer,location,Mells,name,James", list.join(","))
-        println("==== worked! $list")
-    }
-    */
-
     test fun toProperties() {
         val map = hashMapOf("a" to "A", "b" to "B")
         val prop = map.toProperties()
@@ -222,5 +186,4 @@ class MapTest {
         assertEquals("A", prop.getProperty("a", "fail"))
         assertEquals("B", prop.getProperty("b", "fail"))
     }
-
 }