Cleanup ordering, improve API

libraries/stdlib/test/CompareJVMTest.kt

@@ -1,40 +0,0 @@
-package test.compare
-
-import java.util.Comparator
-import kotlin.test.*
-import org.junit.Test
-
-class CompareJVMTest {
-    val v1 = Item("wine", 9)
-    val v2 = Item("beer", 10)
-
-    Test fun sortUsingComparatorHelperMethod() {
-        val c = comparator<Item>({ rating }, { name })
-        println("Created comparator $c")
-
-        val diff = c.compare(v1, v2)
-        assertTrue(diff < 0)
-        val items = arrayListOf(v1, v2)
-        items.sortBy(c)
-        println("Sorted list in rating order $items")
-    }
-
-    Test fun sortUsingCustomComparator() {
-        val c = object : Comparator<Item>{
-            override fun compare(o1: Item, o2: Item): Int {
-                return compareBy(o1, o2, { name }, { rating })
-            }
-            override fun equals(obj: Any?): Boolean {
-                return this == obj
-            }
-        }
-        println("Created comparator $c")
-
-        val diff = c.compare(v1, v2)
-        assertTrue(diff > 0)
-        val items = arrayListOf(v1, v2)
-        items.sortBy(c)
-        println("Sorted list in rating order $items")
-    }
-
-}

libraries/stdlib/test/CompareTest.kt

@@ -1,37 +0,0 @@
-package test.compare
-
-import kotlin.test.*
-import org.junit.Test
-
-class Item(val name: String, val rating: Int): Comparable<Item> {
-    override fun toString() = "Item($name, $rating)"
-
-    public override fun compareTo(other: Item): Int {
-        return compareBy(this, other, { rating }, { name })
-    }
-}
-
-class CompareTest {
-    val v1 = Item("wine", 9)
-    val v2 = Item("beer", 10)
-
-    Test fun compareByCompareTo() {
-        val diff = v1.compareTo(v2)
-        assertTrue(diff < 0)
-    }
-
-    Test fun compareByNameFirst() {
-        val diff = compareBy(v1, v2, { name }, { rating })
-        assertTrue(diff > 0)
-    }
-
-    Test fun compareByRatingFirst() {
-        val diff = compareBy(v1, v2, { rating }, { name })
-        assertTrue(diff < 0)
-    }
-
-    Test fun compareSameObjectsByRatingFirst() {
-        val diff = compareBy(v1, v1, { rating }, { name })
-        assertTrue(diff == 0)
-    }
-}

libraries/stdlib/test/OrderingTest.kt

@@ -0,0 +1,93 @@
+package test.compare
+
+import java.util.*
+import kotlin.test.*
+import org.junit.Test
+
+data class Item(val name: String, val rating: Int) : Comparable<Item> {
+    public override fun compareTo(other: Item): Int {
+        return compareValuesBy(this, other, { it.rating }, { it.name })
+    }
+}
+
+class OrderingTest {
+    val v1 = Item("wine", 9)
+    val v2 = Item("beer", 10)
+
+    Test fun compareByCompareTo() {
+        val diff = v1.compareTo(v2)
+        assertTrue(diff < 0)
+    }
+
+    Test fun compareByNameFirst() {
+        val diff = compareValuesBy(v1, v2, { it.name }, { it.rating })
+        assertTrue(diff > 0)
+    }
+
+    Test fun compareByRatingFirst() {
+        val diff = compareValuesBy(v1, v2, { it.rating }, { it.name })
+        assertTrue(diff < 0)
+    }
+
+    Test fun compareSameObjectsByRatingFirst() {
+        val diff = compareValuesBy(v1, v1, { it.rating }, { it.name })
+        assertTrue(diff == 0)
+    }
+
+    Test fun sortComparatorThenComparator() {
+        val comparator = comparator<Item> {(a, b) -> a.name.compareTo(b.name) } thenComparator {(a, b) -> a.rating.compareTo(b.rating) }
+
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff > 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v2, items[0])
+        assertEquals(v1, items[1])
+    }
+
+    Test fun sortByThenBy() {
+        val comparator = compareBy<Item> { it.rating } thenBy { it.name }
+
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff < 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v1, items[0])
+        assertEquals(v2, items[1])
+    }
+
+    Test fun sortByThenByDescending() {
+        val comparator = compareBy<Item> { it.rating } thenByDescending { it.name }
+
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff < 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v1, items[0])
+        assertEquals(v2, items[1])
+    }
+
+    Test fun sortUsingFunctionalComparator() {
+        val comparator = compareBy<Item>({ it.name }, { it.rating })
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff > 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v2, items[0])
+        assertEquals(v1, items[1])
+    }
+
+    Test fun sortUsingCustomComparator() {
+        val comparator = object : Comparator<Item> {
+            override fun compare(o1: Item, o2: Item): Int {
+                return compareValuesBy(o1, o2, { it.name }, { it.rating })
+            }
+
+            override fun equals(other: Any?): Boolean {
+                return this == other
+            }
+        }
+        val diff = comparator.compare(v1, v2)
+        assertTrue(diff > 0)
+        val items = arrayListOf(v1, v2).sortBy(comparator)
+        assertEquals(v2, items[0])
+        assertEquals(v1, items[1])
+    }
+
+}

libraries/stdlib/test/collections/MapJVMTest.kt

@@ -23,11 +23,7 @@ class MapJVMTest {
 
     test fun toSortedMapWithComparator() {
         val map = mapOf(Pair("c", 3), Pair("bc", 2), Pair("bd", 4), Pair("abc", 1))
-        val c = comparator<String>{ a, b ->
-            val answer = a.length() - b.length()
-            if (answer == 0) a.compareTo(b) else answer
-        }
-        val sorted = map.toSortedMap(c)
+        val sorted = map.toSortedMap(compareBy<String> { it.length() } thenBy { it })
         assertEquals(arrayListOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
         assertEquals(1, sorted["abc"])
         assertEquals(2, sorted["bc"])