Tests to ensure the behavior of the specialized empty List, Set, Map implementations is same as of non-specialized ones.

js/js.libraries/test/core/assertTypeEquals.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2015 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 kotlin.test
+
+public fun assertTypeEquals(expected: Any?, actual: Any?) {
+    //TODO: find analogue
+    //assertEquals(expected?.javaClass, actual?.javaClass)
+}

libraries/stdlib/test/collections/CollectionJVMTest.kt

@@ -151,6 +151,7 @@ class CollectionJVMTest {
 
     test fun emptySetIsSerializable() = testSingletonSerialization(emptySet<Any>())
 
+    test fun emptyMapIsSerializable() = testSingletonSerialization(emptyMap<Any, Any>())
 
     private fun testSingletonSerialization(value: Any) {
         val outputStream = ByteArrayOutputStream()
@@ -168,3 +169,8 @@ class CollectionJVMTest {
         assertTrue(value === result)
     }
 }
+
+
+public fun assertTypeEquals(expected: Any?, actual: Any?) {
+    assertEquals(expected?.javaClass, actual?.javaClass)
+}

libraries/stdlib/test/collections/CollectionTest.kt

@@ -520,4 +520,137 @@ class CollectionTest {
         assertEquals(d, 4)
         assertEquals(e, 5)
     }
+
+
+    test fun specialLists() {
+        compare(arrayListOf<Int>(), listOf<Int>()) { listBehavior() }
+        compare(arrayListOf<Double>(), emptyList<Double>()) { listBehavior() }
+        compare(arrayListOf("value"), listOf("value")) { listBehavior() }
+    }
+
+    test fun specialSets() {
+        compare(linkedSetOf<Int>(), setOf<Int>()) { setBehavior() }
+        compare(hashSetOf<Double>(), emptySet<Double>()) { setBehavior() }
+        compare(listOf("value").toMutableSet(), setOf("value")) { setBehavior() }
+    }
+
+    test fun specialMaps() {
+        compare(hashMapOf<String, Int>(), mapOf<String, Int>()) { mapBehavior() }
+        compare(linkedMapOf<Int, String>(), emptyMap<Int, String>()) { mapBehavior() }
+        compare(linkedMapOf(2 to 3), mapOf(2 to 3)) { mapBehavior() }
+    }
+
+    private fun <T> CompareContext<List<T>>.listBehavior() {
+        equalityBehavior()
+        collectionBehavior()
+        compareProperty( { listIterator() }, { listIteratorBehavior() })
+        compareProperty( { listIterator(0) }, { listIteratorBehavior() })
+
+        propertyFails { listIterator(-1) }
+        propertyFails { listIterator(size() + 1) }
+
+        for (index in expected.indices)
+            propertyEquals { this[index] }
+
+        propertyFails { this[size()] }
+
+        propertyEquals { indexOf(elementAtOrNull(0)) }
+        propertyEquals { lastIndexOf(elementAtOrNull(0)) }
+
+        propertyFails { subList(0, size() + 1)}
+        propertyFails { subList(-1, 0)}
+        propertyEquals { subList(0, size()) }
+    }
+
+    private fun <T> CompareContext<ListIterator<T>>.listIteratorBehavior() {
+        listIteratorProperties()
+
+        while (expected.hasNext()) {
+            propertyEquals { next() }
+            listIteratorProperties()
+        }
+        propertyFails { next() }
+
+        while (expected.hasPrevious()) {
+            propertyEquals { previous() }
+            listIteratorProperties()
+        }
+        propertyFails { previous() }
+    }
+
+    private fun CompareContext<ListIterator<*>>.listIteratorProperties() {
+        propertyEquals { hasNext() }
+        propertyEquals { hasPrevious() }
+        propertyEquals { nextIndex() }
+        propertyEquals { previousIndex() }
+    }
+
+    private fun <T> CompareContext<Iterator<T>>.iteratorBehavior() {
+        propertyEquals { hasNext() }
+
+        while (expected.hasNext()) {
+            propertyEquals { next() }
+            propertyEquals { hasNext() }
+        }
+        propertyFails { next() }
+    }
+
+    private fun <T> CompareContext<Set<T>>.setBehavior(objectName: String = "") {
+        equalityBehavior(objectName)
+        collectionBehavior(objectName)
+        compareProperty({ iterator() }, { iteratorBehavior() })
+    }
+
+    private fun <K, V> CompareContext<Map<K, V>>.mapBehavior() {
+        equalityBehavior()
+        propertyEquals { size() }
+        propertyEquals { isEmpty() }
+
+        (object {}).let { propertyEquals { containsKey(it)}  }
+
+        if (expected.isEmpty().not())
+            propertyEquals { contains(keySet().first()) }
+
+        compareProperty( { keySet() }, { setBehavior("keySet") } )
+        compareProperty( { entrySet() }, { setBehavior("entrySet") } )
+        compareProperty( { values() }, { collectionBehavior("values") })
+    }
+
+    private fun <T> CompareContext<T>.equalityBehavior(objectName: String = "") {
+        val prefix = objectName +  if (objectName.isNotEmpty()) "." else ""
+        equals(objectName)
+        propertyEquals(prefix + "hashCode") { hashCode() }
+        propertyEquals(prefix + "toString") { toString() }
+    }
+
+
+    private fun <T> CompareContext<Collection<T>>.collectionBehavior(objectName: String = "") {
+        val prefix = objectName +  if (objectName.isNotEmpty()) "." else ""
+        propertyEquals (prefix + "size") { size() }
+        propertyEquals (prefix + "isEmpty") { isEmpty() }
+
+        (object {}).let { propertyEquals { contains(it)}  }
+        propertyEquals { contains(firstOrNull()) }
+        propertyEquals { containsAll(this) }
+    }
+
+}
+
+private fun compare<T>(expected: T, actual: T, block: CompareContext<T>.() -> Unit) = CompareContext(expected, actual).block()
+
+private class CompareContext<out T>(public val expected: T, public val actual: T) {
+
+    public fun equals(message: String = "") { assertEquals(expected, actual, message) }
+    public fun propertyEquals<P>(message: String = "", getter: T.() -> P) { assertEquals(expected.getter(), actual.getter(), message) }
+    public fun propertyFails(getter: T.() -> Unit) { assertFailEquals({expected.getter()}, {actual.getter()}) }
+    public fun compareProperty<P>(getter: T.() -> P, block: CompareContext<P>.() -> Unit) {
+        compare(expected.getter(), actual.getter(), block)
+    }
+
+    private fun assertFailEquals(expected: () -> Unit, actual: () -> Unit) {
+        val expectedFail = fails(expected)
+        val actualFail = fails(actual)
+        //assertEquals(expectedFail != null, actualFail != null)
+        assertTypeEquals(expectedFail, actualFail)
+    }
 }