Clean size/length/first/head/empty properties and functions.

libraries/stdlib/test/ExceptionTest.kt

@@ -40,6 +40,6 @@ class ExceptionTest {
         }
 
         val bytes = assertNotNull(byteBuffer.toByteArray())
-        assertTrue(bytes.size > 10)
+        assertTrue(bytes.size() > 10)
     }
 }

libraries/stdlib/test/OldStdlibTest.kt

@@ -10,13 +10,13 @@ import org.junit.Test as test
 class OldStdlibTest() {
     test fun testCollectionEmpty() {
         assertNot {
-            listOf(0, 1, 2).empty
+            listOf(0, 1, 2).isEmpty()
         }
     }
 
     test fun testCollectionSize() {
         assertTrue {
-            listOf(0, 1, 2).size == 3
+            listOf(0, 1, 2).size() == 3
         }
     }
 

libraries/stdlib/test/TuplesTest.kt

@@ -40,8 +40,8 @@ class PairTest {
     }
 
     test fun pairHashSet() {
-        val s = hashSet(Pair(1, "a"), Pair(1, "b"), Pair(1, "a"))
-        assertEquals(2, s.size)
+        val s = hashSetOf(Pair(1, "a"), Pair(1, "b"), Pair(1, "a"))
+        assertEquals(2, s.size())
         assertTrue(s.contains(p))
     }
 }
@@ -85,8 +85,8 @@ class TripleTest {
     }
 
     test fun tripleHashSet() {
-        val s = hashSet(Triple(1, "a", 0.07), Triple(1, "b", 0.07), Triple(1, "a", 0.07))
-        assertEquals(2, s.size)
+        val s = hashSetOf(Triple(1, "a", 0.07), Triple(1, "b", 0.07), Triple(1, "a", 0.07))
+        assertEquals(2, s.size())
         assertTrue(s.contains(t))
     }
 }

libraries/stdlib/test/collections/ArraysJVMTest.kt

@@ -201,13 +201,13 @@ class ArraysJVMTest {
     test fun orEmptyNull() {
         val x: Array<String>? = null
         val xArray: Array<String> = x.orEmpty()
-        expect(0) { xArray.size }
+        expect(0) { xArray.size() }
     }
 
     test fun orEmptyNotNull() {
         val x: Array<String>? = array("1", "2")
         val xArray: Array<String> = x.orEmpty()
-        expect(2) { xArray.size }
+        expect(2) { xArray.size() }
         expect("1") { xArray[0] }
         expect("2") { xArray[1] }
     }

libraries/stdlib/test/collections/ArraysTest.kt

@@ -37,7 +37,7 @@ class ArraysTest {
         val arr = ByteArray(2)
 
         val expected: Byte = 0
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(expected, arr[0])
         assertEquals(expected, arr[1])
     }
@@ -46,7 +46,7 @@ class ArraysTest {
         val arr = ShortArray(2)
 
         val expected: Short = 0
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(expected, arr[0])
         assertEquals(expected, arr[1])
     }
@@ -54,7 +54,7 @@ class ArraysTest {
     test fun intArray() {
         val arr = IntArray(2)
 
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(0, arr[0])
         assertEquals(0, arr[1])
     }
@@ -63,7 +63,7 @@ class ArraysTest {
         val arr = LongArray(2)
 
         val expected: Long = 0
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(expected, arr[0])
         assertEquals(expected, arr[1])
     }
@@ -72,7 +72,7 @@ class ArraysTest {
         val arr = FloatArray(2)
 
         val expected: Float = 0.0.toFloat()
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(expected, arr[0])
         assertEquals(expected, arr[1])
     }
@@ -80,7 +80,7 @@ class ArraysTest {
     test fun doubleArray() {
         val arr = DoubleArray(2)
 
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(0.0, arr[0])
         assertEquals(0.0, arr[1])
     }
@@ -89,14 +89,14 @@ class ArraysTest {
         val arr = CharArray(2)
 
         val expected: Char = '\u0000'
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(expected, arr[0])
         assertEquals(expected, arr[1])
     }
 
     test fun booleanArray() {
         val arr = BooleanArray(2)
-        assertEquals(arr.size, 2)
+        assertEquals(arr.size(), 2)
         assertEquals(false, arr[0])
         assertEquals(false, arr[1])
     }

libraries/stdlib/test/collections/CollectionJVMTest.kt

@@ -18,14 +18,14 @@ class CollectionJVMTest {
     }
 
 
-    test fun filterIntolinkedListOf() {
+    test fun filterIntoLinkedList() {
         val data = arrayListOf("foo", "bar")
         val foo = data.filterTo(linkedListOf<String>()) { it.startsWith("f") }
 
         assertTrue {
             foo.all { it.startsWith("f") }
         }
-        assertEquals(1, foo.size)
+        assertEquals(1, foo.size())
         assertEquals(linkedListOf("foo"), foo)
 
         assertTrue {
@@ -40,7 +40,7 @@ class CollectionJVMTest {
         assertTrue {
             foo.all { !it.startsWith("f") }
         }
-        assertEquals(1, foo.size)
+        assertEquals(1, foo.size())
         assertEquals(linkedListOf("bar"), foo)
 
         assertTrue {
@@ -52,7 +52,7 @@ class CollectionJVMTest {
         val data = arrayListOf(null, "foo", null, "bar")
         val foo = data.filterNotNullTo(linkedListOf<String>())
 
-        assertEquals(2, foo.size)
+        assertEquals(2, foo.size())
         assertEquals(linkedListOf("foo", "bar"), foo)
 
         assertTrue {
@@ -63,7 +63,7 @@ class CollectionJVMTest {
     test fun filterIntoSortedSet() {
         val data = arrayListOf("foo", "bar")
         val sorted = data.filterTo(sortedSetOf<String>()) { it.length == 3 }
-        assertEquals(2, sorted.size)
+        assertEquals(2, sorted.size())
         assertEquals(sortedSetOf("bar", "foo"), sorted)
         assertTrue {
             sorted is TreeSet<String>
@@ -93,7 +93,7 @@ class CollectionJVMTest {
         val data = arrayListOf("foo", "bar")
         val arr = data.toArray()
         println("Got array ${arr}")
-        assertEquals(2, arr.size)
+        assertEquals(2, arr.size())
         todo {
             assertTrue {
                 arr is Array<String>

libraries/stdlib/test/collections/CollectionTest.kt

@@ -27,7 +27,7 @@ class CollectionTest {
         val data = arrayListOf(null, "foo", null, "bar")
         val foo = data.filterNotNull()
 
-        assertEquals(2, foo.size)
+        assertEquals(2, foo.size())
         assertEquals(arrayListOf("foo", "bar"), foo)
 
         assertTrue {
@@ -38,7 +38,7 @@ class CollectionTest {
     test fun mapNotNull() {
         val data = arrayListOf(null, "foo", null, "bar")
         val foo = data.mapNotNull { it.length }
-        assertEquals(2, foo.size)
+        assertEquals(2, foo.size())
         assertEquals(arrayListOf(3, 3), foo)
 
         assertTrue {
@@ -53,7 +53,7 @@ class CollectionTest {
         assertTrue {
             foo.all { it.startsWith("f") }
         }
-        assertEquals(1, foo.size)
+        assertEquals(1, foo.size())
         assertEquals(hashSetOf("foo"), foo)
 
         assertTrue {
@@ -83,7 +83,7 @@ class CollectionTest {
     test fun foldWithDifferentTypes() {
         expect(7) {
             val numbers = arrayListOf("a", "ab", "abc")
-            numbers.fold(1) { a, b -> a + b.size }
+            numbers.fold(1) { a, b -> a + b.length() }
         }
 
         expect("1234") {
@@ -136,7 +136,7 @@ class CollectionTest {
 
     test fun partition() {
         val data = arrayListOf("foo", "bar", "something", "xyz")
-        val pair = data.partition { it.size == 3 }
+        val pair = data.partition { it.length() == 3 }
 
         assertEquals(arrayListOf("foo", "bar", "xyz"), pair.first, "pair.first")
         assertEquals(arrayListOf("something"), pair.second, "pair.second")
@@ -181,7 +181,7 @@ class CollectionTest {
         assertEquals(4, listOfPairs[3].first)
 
         val l3 = byLength.getOrElse(3, { ArrayList<String>() })
-        assertEquals(2, l3.size)
+        assertEquals(2, l3.size())
     }
 
     test fun plusRanges() {
@@ -281,14 +281,14 @@ class CollectionTest {
     test fun takeWhile() {
         val coll = arrayListOf("foo", "bar", "abc")
         assertEquals(arrayListOf("foo"), coll.takeWhile { it.startsWith("f") })
-        assertEquals(arrayListOf("foo", "bar", "abc"), coll.takeWhile { it.size == 3 })
+        assertEquals(arrayListOf("foo", "bar", "abc"), coll.takeWhile { it.length() == 3 })
     }
 
     test fun copyToArray() {
         val data = arrayListOf("foo", "bar")
         val arr = data.copyToArray()
         println("Got array ${arr}")
-        assertEquals(2, arr.size)
+        assertEquals(2, arr.size())
         todo {
             assertTrue {
                 arr is Array<String>
@@ -347,7 +347,7 @@ class CollectionTest {
         val indices = data.indices
         assertEquals(0, indices.start)
         assertEquals(1, indices.end)
-        assertEquals(indices, data.size.indices)
+        assertEquals(indices, data.size().indices)
     }
 
     test fun contains() {

libraries/stdlib/test/collections/ImmutableArrayListTest.kt

@@ -19,7 +19,7 @@ class ImmutableArrayListTest() : TestCase() {
     fun testGet() {
         for (length in 0 .. 55) {
             val list = buildIntArray(length, 19)
-            assertEquals(length, list.size)
+            assertEquals(length, list.size())
             checkList(list, length, 19)
         }
     }
@@ -34,7 +34,7 @@ class ImmutableArrayListTest() : TestCase() {
 
 
     private fun checkList(list: List<Int>, expectedLength: Int, expectedFirstValue: Int) {
-        assertEquals(expectedLength, list.size)
+        assertEquals(expectedLength, list.size())
         for (i in 0 .. expectedLength - 1) {
             assertEquals(expectedFirstValue + i, list[i])
         }

libraries/stdlib/test/collections/IterableTests.kt

@@ -107,7 +107,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         val foo = data.filter { it.startsWith("f") }
         expect(true) { foo is List<String> }
         expect(true) { foo.all { it.startsWith("f") } }
-        expect(1) { foo.size }
+        expect(1) { foo.size() }
         assertEquals(listOf("foo"), foo)
     }
 
@@ -115,7 +115,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         val notFoo = data.filterNot { it.startsWith("f") }
         expect(true) { notFoo is List<String> }
         expect(true) { notFoo.none { it.startsWith("f") } }
-        expect(1) { notFoo.size }
+        expect(1) { notFoo.size() }
         assertEquals(listOf("bar"), notFoo)
     }
 
@@ -159,7 +159,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         assertTrue {
             lengths.all { it == 3 }
         }
-        assertEquals(2, lengths.size)
+        assertEquals(2, lengths.size())
         assertEquals(arrayListOf(3, 3), lengths)
     }
 
@@ -220,7 +220,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
     Test
     fun reduce() {
         val reduced = data.reduce {a, b -> a + b }
-        assertEquals(6, reduced.size)
+        assertEquals(6, reduced.length())
         assertTrue(reduced == "foobar" || reduced == "barfoo")
     }
 }

libraries/stdlib/test/collections/ListSpecificTest.kt

@@ -13,7 +13,7 @@ class ListSpecificTest {
 
     Test fun tail() {
         val data = arrayListOf("foo", "bar", "whatnot")
-        val actual = data.tail
+        val actual = data.drop(1)
         val expected = arrayListOf("bar", "whatnot")
         assertEquals(expected, actual)
     }
@@ -30,14 +30,7 @@ class ListSpecificTest {
     }
 
     Test fun utils() {
-        assertNull(empty.head)
-        assertNull(empty.first)
-        assertNull(empty.last)
         assertEquals(-1, empty.lastIndex)
-
-        assertEquals("foo", data.head)
-        assertEquals("foo", data.first)
-        assertEquals("bar", data.last)
         assertEquals(1, data.lastIndex)
     }
 

libraries/stdlib/test/dom/DomBuilderTest.kt

@@ -86,7 +86,7 @@ class DomBuilderTest() {
             }
 
         }
-        val grandChild = doc["grandChild"].first
+        val grandChild = doc["grandChild"].firstOrNull()
         if (grandChild != null) {
             assertEquals("Hello World!", grandChild.text)
             assertEquals(" bar tiny", grandChild.attribute("class"))
@@ -96,7 +96,7 @@ class DomBuilderTest() {
 
             assertTrue(classSet.contains("bar"))
             assertTrue(classSet.contains("tiny"))
-            assertTrue(classSet.size == 2 )
+            assertTrue(classSet.size() == 2 )
             assertFalse(classSet.contains("doesNotExist"))
 
             // lets add a new class and some existing classes
@@ -114,12 +114,12 @@ class DomBuilderTest() {
         } else {
             fail("Not an Element $grandChild")
         }
-        val child = doc["child"].first
+        val child = doc["child"].firstOrNull()
         if (child != null) {
             val gc1 = child.childElements("grandChild")
-            assertEquals(1, gc1.size, "Expected a single child but found $gc1")
+            assertEquals(1, gc1.size(), "Expected a single child but found $gc1")
             val gc2 = child.childElements("grandChild2")
-            assertEquals(1, gc2.size, "Expected a single child but found $gc2")
+            assertEquals(1, gc2.size(), "Expected a single child but found $gc2")
         } else {
             fail("No child found!")
         }

libraries/stdlib/test/io/Files.kt

@@ -15,7 +15,7 @@ class FilesTest {
         File.createTempFile("temp3", ".kt", dir)
 
         val result = dir.listFiles { it.getName().endsWith(".kt") }
-        assertEquals(2, result!!.size)
+        assertEquals(2, result!!.size())
     }
 
     test fun recurse() {

libraries/stdlib/test/js/JsArrayScript.kt

@@ -5,7 +5,7 @@ fun testSize(): Int {
     val a2 = array("foo")
     val a3 = array("foo", "bar")
 
-    return a1.size + a2.size + a3.size
+    return a1.size() + a2.size() + a3.size()
 }
 
 fun testToListToString(): String {

libraries/stdlib/test/js/JsArrayTest.kt

@@ -11,9 +11,9 @@ class JsArrayTest {
         val a2 = array("foo")
         val a3 = array("foo", "bar")
 
-        assertEquals(0, a1.size)
-        assertEquals(1, a2.size)
-        assertEquals(2, a3.size)
+        assertEquals(0, a1.size())
+        assertEquals(1, a2.size())
+        assertEquals(2, a3.size())
 
         assertEquals("[]", a1.toList().toString())
         assertEquals("[foo]", a2.toList().toString())
@@ -25,7 +25,7 @@ class JsArrayTest {
         var c: Collection<String>  = array("A", "B", "C").toList()
         var a = ArrayList(c)
 
-        assertEquals(3, a.size)
+        assertEquals(3, a.size())
         assertEquals("A", a[0])
         assertEquals("B", a[1])
         assertEquals("C", a[2])

libraries/stdlib/test/js/MapJsTest.kt

@@ -138,8 +138,8 @@ abstract class MapJsTest {
         assertFalse(data.isEmpty())
         assertFalse(data.empty)
 
-        assertEquals(KEYS.size, data.size())
-        assertEquals(KEYS.size, data.size)
+        assertEquals(KEYS.size(), data.size())
+        assertEquals(KEYS.size(), data.size)
     }
 
     // #KT-3035
@@ -200,7 +200,7 @@ abstract class MapJsTest {
         val map = createTestMap()
         val newMap = emptyMutableMap()
         newMap.putAll(map)
-        assertEquals(KEYS.size, newMap.size)
+        assertEquals(KEYS.size(), newMap.size)
     }
 
     test fun mapRemove() {

libraries/stdlib/test/text/StringJVMTest.kt

@@ -48,14 +48,14 @@ class StringJVMTest {
     test fun testSplitByChar() {
         val s = "ab\n[|^$&\\]^cd"
         var list = s.split('b');
-        assertEquals(2, list.size)
+        assertEquals(2, list.size())
         assertEquals("a", list[0])
         assertEquals("\n[|^$&\\]^cd", list[1])
         list = s.split('^')
-        assertEquals(3, list.size)
+        assertEquals(3, list.size())
         assertEquals("cd", list[2])
         list = s.split('.')
-        assertEquals(1, list.size)
+        assertEquals(1, list.size())
         assertEquals(s, list[0])
     }
 
@@ -113,14 +113,14 @@ class StringJVMTest {
 
     test fun find() {
         val data = "a1b2c3"
-        assertEquals('1', data.find { it.isDigit() })
-        assertNull(data.find { it.isUpperCase() })
+        assertEquals('1', data.first { it.isDigit() })
+        assertNull(data.firstOrNull { it.isUpperCase() })
     }
 
     test fun findNot() {
         val data = "1a2b3c"
-        assertEquals('a', data.findNot { it.isDigit() })
-        assertNull(data.findNot { it.isJavaLetterOrDigit() })
+        assertEquals('a', data.filterNot { it.isDigit() }.firstOrNull())
+        assertNull(data.filterNot { it.isJavaLetterOrDigit() }.firstOrNull())
     }
 
     test fun partition() {
@@ -165,7 +165,7 @@ class StringJVMTest {
     test fun flatMap() {
         val data = "abcd"
         val result = data.flatMap { listOf(it) }
-        assertEquals(data.size, result.count())
+        assertEquals(data.length(), result.count())
         assertEquals(data.toCharList(), result)
     }