Tests for minus operation for collections, sets, iterables and sequences.

libraries/stdlib/test/collections/CollectionTest.kt

@@ -234,6 +234,53 @@ class CollectionTest {
         assertEquals(l, ml)
     }
 
+
+    private fun testMinus(expected: List<String>? = null, doMinus: (List<String>) -> List<String>) {
+        val a = listOf("foo", "bar", "bar")
+        val b: List<String> = doMinus(a)
+        val expected_ = expected ?: listOf("foo")
+        assertEquals(expected_, b.toList())
+    }
+
+    test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
+    test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
+    test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
+    test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
+
+    test fun minusIsEager() {
+        val source = listOf("foo", "bar")
+        val list = arrayListOf<String>()
+        val result = source - list
+
+        list += "foo"
+        assertEquals(source, result)
+        list += "bar"
+        assertEquals(source, result)
+    }
+
+    test fun minusAssign() {
+        // lets use a mutable variable of readonly list
+        val data: List<String> = listOf("cheese", "foo", "beer", "cheese", "wine")
+        var l = data
+        l -= "cheese"
+        assertEquals(listOf("foo", "beer", "cheese", "wine"), l)
+        l = data
+        l -= listOf("cheese", "beer")
+        assertEquals(listOf("foo", "wine"), l)
+        l -= arrayOf("wine", "bar")
+        assertEquals(listOf("foo"), l)
+
+        val ml = arrayListOf("cheese", "cheese", "foo", "beer", "cheese", "wine")
+        ml -= "cheese"
+        assertEquals(listOf("cheese", "foo", "beer", "cheese", "wine"), ml)
+        ml -= listOf("cheese", "beer")
+        assertEquals(listOf("foo", "wine"), ml)
+        ml -= arrayOf("wine", "bar")
+        assertEquals(listOf("foo"), ml)
+    }
+
+
+
     test fun requireNoNulls() {
         val data = arrayListOf<String?>("foo", "bar")
         val notNull = data.requireNoNulls()

libraries/stdlib/test/collections/IterableTests.kt

@@ -308,4 +308,45 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         assertEquals(listOf("foo", "bar", "foo", "beer", "cheese", "wine", "zoo", "g"), result)
     }
 
+    Test
+    fun minusElement() {
+        val result = data - "foo" - "g"
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusCollection() {
+        val result = data - listOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusArray() {
+        val result = data - arrayOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusSequence() {
+        val result = data - sequenceOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusAssign() {
+        // lets use a mutable variable
+        var result: Iterable<String> = data
+        result -= "foo"
+        assertEquals(listOf("bar"), result)
+        result = data
+        result -= listOf("beer", "bar")
+        assertEquals(listOf("foo"), result)
+        result = data
+        result -= arrayOf("bar", "foo")
+        assertEquals(emptyList<String>(), result)
+        result = data
+        result -= sequenceOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
 }

libraries/stdlib/test/collections/SequenceTest.kt

@@ -156,6 +156,43 @@ public class SequenceTest {
         assertEquals(listOf("a", "foo", "beer", "cheese", "wine", "bar", "foo"), seq.toList())
     }
 
+    private fun testMinus(expected: List<String>? = null, doMinus: (Sequence<String>) -> Sequence<String>) {
+        val a = sequenceOf("foo", "bar", "bar")
+        val b: Sequence<String> = doMinus(a)
+        val expected_ = expected ?: listOf("foo")
+        assertEquals(expected_, b.toList())
+    }
+
+    test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
+    test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
+    test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
+    test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
+
+    test fun minusIsLazyIterated() {
+        val seq = sequenceOf("foo", "bar")
+        val list = arrayListOf<String>()
+        val result = seq - list
+
+        list += "foo"
+        assertEquals(listOf("bar"), result.toList())
+        list += "bar"
+        assertEquals(emptyList<String>(), result.toList())
+    }
+
+    test fun minusAssign() {
+        // lets use a mutable variable of readonly list
+        val data = sequenceOf("cheese", "foo", "beer", "cheese", "wine")
+        var l = data
+        l -= "cheese"
+        assertEquals(listOf("foo", "beer", "cheese", "wine"), l.toList())
+        l = data
+        l -= listOf("cheese", "beer")
+        assertEquals(listOf("foo", "wine"), l.toList())
+        l -= arrayOf("wine", "bar")
+        assertEquals(listOf("foo"), l.toList())
+    }
+
+
 
     test fun iterationOverSequence() {
         var s = ""

libraries/stdlib/test/collections/SetOperationsTest.kt

@@ -64,4 +64,15 @@ class SetOperationsTest {
         assertEquals(set, mset)
     }
 
+    private fun testMinus(doMinus: (Set<String>) -> Set<String>) {
+        val a = setOf("foo", "bar")
+        val b: Set<String> = doMinus(a)
+        assertEquals(setOf("foo"), b)
+    }
+
+    test fun minusElement() = testMinus { it - "bar" - "zoo" }
+    test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
+    test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
+    test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
+
 }