Replace ArrayList<Any>() with stdlib_emptyListClass() and fix test. #KT-6013 Fixed

libraries/stdlib/src/kotlin/collections/JUtil.kt

@@ -3,11 +3,11 @@ package kotlin
 import java.util.*
 
 private class stdlib_emptyListClass : List<Any> by ArrayList<Any>() {}
-private val stdlib_emptyList : List<Any> = ArrayList<Any>() // TODO: Change to stdlib_emptyListClass() when KT-5192 is fixed
+private val stdlib_emptyList : List<Any> = stdlib_emptyListClass()
 private fun stdlib_emptyList<T>() = stdlib_emptyList as List<T>
 
 private class stdlib_emptyMapClass : Map<Any, Any> by HashMap<Any, Any>() {}
-private val stdlib_emptyMap : Map<Any, Any> = HashMap<Any, Any>() // TODO: Change to stdlib_emptyMapClass() when KT-5192 is fixed
+private val stdlib_emptyMap : Map<Any, Any> = stdlib_emptyMapClass()
 private fun stdlib_emptyMap<K,V>() = stdlib_emptyMap as Map<K,V>
 
 /** Returns a new read-only list of given elements */

libraries/stdlib/test/collections/ArraysTest.kt

@@ -192,8 +192,8 @@ class ArraysTest {
         assertEquals(listOf("B"), array("A", "B", "C").slice(1..1))
         assertEquals(listOf('E', 'B', 'C'), array('A', 'B', 'C', 'E').slice(iter))
 
-        assertEquals(listOf<Int>(), array<Int>().slice(5..4))
-        assertEquals(listOf<Int>(), array(1, 2, 3).slice(5..1))
+        assertTrue(array<Int>().slice(5..4).none())
+        assertTrue(array(1, 2, 3).slice(5..1).none())
         assertEquals(listOf(2, 3, 9), array(2, 3, 9, 2, 3, 9).slice(iter))
         assertEquals(listOf(2.0, 3.0), array(2.0, 3.0, 9.0).slice(0..1))
         assertEquals(listOf(2f, 3f), array(2f, 3f, 9f).slice(0..1))
@@ -204,7 +204,7 @@ class ArraysTest {
     }
 
     test fun toSortedList() {
-        assertEquals(listOf<Long>(), array<Long>().toSortedList())
+        assertTrue(array<Long>().toSortedList().none())
         assertEquals(listOf(1), array(1).toSortedList())
         assertEquals(listOf("aab", "aba", "ac"), array("ac", "aab", "aba").toSortedList())
     }

libraries/stdlib/test/collections/CollectionTest.kt

@@ -442,8 +442,8 @@ class CollectionTest {
         expect(listOf(1, 2, 3, 4, 5)) { (1..10).toList().take(5) }
         expect(listOf(1, 2)) { (1..10) take 2 }
         expect(listOf(1, 2)) { (1..10).toList().take(2) }
-        expect(listOf<Long>()) { (0L..5L) take 0 }
-        expect(listOf<Long>()) { listOf(1L) take 0 }
+        expect(true) { (0L..5L).take(0).none() }
+        expect(true) { listOf(1L).take(0).none() }
         expect(listOf(1)) { (1..1) take 10 }
         expect(listOf(1)) { listOf(1) take 10 }
     }

libraries/stdlib/test/collections/SetOperationsTest.kt

@@ -6,7 +6,7 @@ import org.junit.Test as test
 class SetOperationsTest {
     test fun distinct() {
         assertEquals(listOf(1, 3, 5), listOf(1, 3, 3, 1, 5, 1, 3).distinct().toList())
-        assertEquals(listOf<Int>(), listOf<Int>().distinct().toList())
+        assertTrue(listOf<Int>().distinct().none())
     }
 
     test fun union() {
@@ -17,14 +17,14 @@ class SetOperationsTest {
     test fun subtract() {
         assertEquals(listOf(1, 3), listOf(1, 3).subtract(listOf(5)).toList())
         assertEquals(listOf(1, 3), listOf(1, 3, 5).subtract(listOf(5)).toList())
-        assertEquals(listOf<Int>(), listOf(1, 3, 5).subtract(listOf(1, 3, 5)).toList())
-        assertEquals(listOf<Int>(), listOf<Int>().subtract(listOf(1)).toList())
+        assertTrue(listOf(1, 3, 5).subtract(listOf(1, 3, 5)).none())
+        assertTrue(listOf<Int>().subtract(listOf(1)).none())
     }
 
     test fun intersect() {
-        assertEquals(listOf<Int>(), listOf(1, 3).intersect(listOf(5)).toList())
+        assertTrue(listOf(1, 3).intersect(listOf(5)).none())
         assertEquals(listOf(5), listOf(1, 3, 5).intersect(listOf(5)).toList())
         assertEquals(listOf(1, 3, 5), listOf(1, 3, 5).intersect(listOf(1, 3, 5)).toList())
-        assertEquals(listOf<Int>(), listOf<Int>().intersect(listOf(1)).toList())
+        assertTrue(listOf<Int>().intersect(listOf(1)).none())
     }
 }

libraries/stdlib/test/collections/StreamTest.kt

@@ -197,7 +197,7 @@ public class StreamTest {
 
     test fun flatMapOnEmpty() {
         val result = streamOf<Int>().flatMap { streamOf(0..it) }
-        assertEquals(listOf<Int>(), result.toList())
+        assertTrue(result.none())
     }
 
     test fun flatMapWithEmptyItems() {

libraries/stdlib/test/language/RangeIterationJVMTest.kt

@@ -12,8 +12,8 @@ import java.lang.Long.MAX_VALUE as MaxL
 import java.lang.Long.MIN_VALUE as MinL
 import java.lang.Character.MAX_VALUE as MaxC
 import java.lang.Character.MIN_VALUE as MinC
-import kotlin.test.assertEquals
 import org.junit.Test as test
+import kotlin.test.*
 
 // Test data for codegen is generated from this class. If you change it, rerun GenerateTests
 public class RangeIterationJVMTest {
@@ -28,7 +28,10 @@ public class RangeIterationJVMTest {
         assertEquals(expectedEnd, sequence.end)
         assertEquals(expectedIncrement, sequence.increment)
 
-        assertEquals(expectedElements, sequence.toList())
+        if (expectedElements.none())
+            assertTrue(sequence.none())
+        else
+            assertEquals(expectedElements, sequence.toList())
     }
 
     test fun infiniteSteps() {

libraries/stdlib/test/language/RangeIterationTest.kt

@@ -1,7 +1,7 @@
 package language
 
-import kotlin.test.assertEquals
 import org.junit.Test as test
+import kotlin.test.*
 
 // Test data for codegen is generated from this class. If you change it, rerun GenerateTests
 public class RangeIterationTest {
@@ -16,7 +16,10 @@ public class RangeIterationTest {
         assertEquals(expectedEnd, sequence.end)
         assertEquals(expectedIncrement, sequence.increment)
 
-        assertEquals(expectedElements, sequence.toList())
+        if (expectedElements.none())
+            assertTrue(sequence.none())
+        else
+            assertEquals(expectedElements, sequence.toList())
     }
 
     test fun emptyConstant() {