Tests for plus on collections, sets, sequences.

libraries/stdlib/test/collections/ArraysTest.kt

@@ -360,6 +360,15 @@ class ArraysTest {
         assertArrayNotSameButEquals(longArrayOf(1, 2), longOnePlus(2), "LongArray.plus")
     }
 
+    test fun plusAssign() {
+        // lets use a mutable variable
+        var result = arrayOf("a")
+        result += "foo"
+        result += listOf("beer")
+        result += arrayOf("cheese", "wine")
+        assertArrayNotSameButEquals(arrayOf("a", "foo", "beer", "cheese", "wine"), result)
+    }
+
     test fun first() {
         expect(1) { arrayOf(1, 2, 3).first() }
         expect(2) { arrayOf(1, 2, 3).first { it % 2 == 0 } }

libraries/stdlib/test/collections/CollectionTest.kt

@@ -197,16 +197,11 @@ class CollectionTest {
         assertEquals(listOf(2, 4, 6), range)
     }
 
-    test fun plus() {
+    test fun plusElement() {
         val list = listOf("foo", "bar")
-        val list2 = list + "cheese"
+        val list2: List<String> = list + "cheese"
         assertEquals(listOf("foo", "bar"), list)
         assertEquals(listOf("foo", "bar", "cheese"), list2)
-
-        // lets use a mutable variable
-        var list3 = listOf("a", "b")
-        list3 += "c"
-        assertEquals(listOf("a", "b", "c"), list3)
     }
 
     test fun plusCollectionBug() {
@@ -217,15 +212,27 @@ class CollectionTest {
     test fun plusCollection() {
         val a = listOf("foo", "bar")
         val b = listOf("cheese", "wine")
-        val list = a + b
+        val list: List<String> = a + b
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
+    }
+
+    test fun plusArray() {
+        val a = listOf("foo", "bar")
+        val b = arrayOf("cheese", "wine")
+        val list: List<String> = a + b
         assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
 
-        // lets use a mutable variable
-        var ml: List<String> = a
-        ml += "beer"
-        ml += b
-        ml += "z"
-        assertEquals(listOf("foo", "bar", "beer", "cheese", "wine", "z"), ml)
+    }
+
+    test fun plusAssign() {
+        // lets use a mutable variable of readonly list
+        var l: List<String> = listOf("cheese")
+        val lOriginal = l
+        l += "foo"
+        l += listOf("beer")
+        l += arrayOf("cheese", "wine")
+        assertEquals(listOf("cheese", "foo", "beer", "cheese", "wine"), l)
+        assertTrue(l !== lOriginal)
     }
 
     test fun requireNoNulls() {

libraries/stdlib/test/collections/IterableTests.kt

@@ -281,4 +281,33 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         val result = data.joinToString(separator = "-") { it.toUpperCase() }
         assertEquals("FOO-BAR", result)
     }
+
+    Test
+    fun plusElement() {
+        val result = data + "zoo" + "g"
+        assertEquals(listOf("foo", "bar", "zoo", "g"), result)
+    }
+
+    Test
+    fun plusCollection() {
+        val result = data + listOf("zoo", "g")
+        assertEquals(listOf("foo", "bar", "zoo", "g"), result)
+    }
+
+    Test
+    fun plusArray() {
+        val result = data + arrayOf("zoo", "g")
+        assertEquals(listOf("foo", "bar", "zoo", "g"), result)
+    }
+
+    Test
+    fun plusAssign() {
+        // lets use a mutable variable
+        var result: Iterable<String> = data
+        result += "foo"
+        result += listOf("beer")
+        result += arrayOf("cheese", "wine")
+        assertEquals(listOf("foo", "bar", "foo", "beer", "cheese", "wine"), result)
+    }
+
 }

libraries/stdlib/test/collections/SequenceTest.kt

@@ -132,37 +132,40 @@ public class SequenceTest {
         assertEquals("144, 233, 377, 610, 987", fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.joinToString())
     }
 
-    test fun plus() {
+    test fun plusElement() {
         val sequence = sequenceOf("foo", "bar")
-        val sequenceCheese = sequence + "cheese"
+        val sequenceCheese: Sequence<String> = sequence + "cheese"
         assertEquals(listOf("foo", "bar", "cheese"), sequenceCheese.toList())
-
-        // lets use a mutable variable
-        var mi = sequenceOf("a", "b")
-        mi += "c"
-        assertEquals(listOf("a", "b", "c"), mi.toList())
     }
 
     test fun plusCollection() {
         val a = sequenceOf("foo", "bar")
         val b = listOf("cheese", "wine")
-        val sequence = a + b
+        val sequence: Sequence<String> = a + b
         assertEquals(listOf("foo", "bar", "cheese", "wine"), sequence.toList())
+    }
 
+    test fun plusArray() {
+        val a = sequenceOf("foo", "bar")
+        val b = listOf("cheese", "wine")
+        val sequence: Sequence<String> = a + b
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), sequence.toList())
+    }
+
+    test fun plusAssign() {
         // lets use a mutable variable
         var ml = sequenceOf("a")
-        ml += a
-        ml += "beer"
-        ml += b
-        ml += "z"
-        assertEquals(listOf("a", "foo", "bar", "beer", "cheese", "wine", "z"), ml.toList())
+        ml += "foo"
+        ml += listOf("beer")
+        ml += arrayOf("cheese", "wine")
+        assertEquals(listOf("a", "foo", "beer", "cheese", "wine"), ml.toList())
     }
 
 
     test fun iterationOverSequence() {
         var s = ""
         for (i in sequenceOf(0, 1, 2, 3, 4, 5)) {
-            s = s + i.toString()
+            s += i.toString()
         }
         assertEquals("012345", s)
     }

libraries/stdlib/test/collections/SetOperationsTest.kt

@@ -32,4 +32,34 @@ class SetOperationsTest {
         assertEquals(listOf(1, 3, 5), listOf(1, 3, 5).intersect(listOf(1, 3, 5)).toList())
         assertTrue(listOf<Int>().intersect(listOf(1)).none())
     }
+
+    test fun plusElement() {
+        val set = setOf("foo")
+        val result: Set<String> = set + "bar" + "bar"
+        assertEquals(setOf("foo", "bar"), result)
+    }
+
+    test fun plusCollection() {
+        val set = setOf("foo")
+        val result: Set<String> = set + listOf("bar", "bar")
+        assertEquals(setOf("foo", "bar"), result)
+    }
+
+    test fun plusArray() {
+        val set = setOf("foo")
+        val result: Set<String> = set + arrayOf("foo", "bar")
+        assertEquals(setOf("foo", "bar"), result)
+    }
+
+    test fun plusAssign() {
+        // lets use a mutable variable
+        var set = setOf("a")
+        val setOriginal = set
+        set += "foo"
+        set += listOf("beer")
+        set += arrayOf("cheese", "wine")
+        assertEquals(setOf("a", "foo", "beer", "cheese", "wine"), set)
+        assertTrue(set !== setOriginal)
+    }
+
 }