Improve code coverage of ImmutableArray

Scratching an itch... brings the sequence and branch coverage of ImmutableArray and ImmutableArray<T> to within a few branches of 100%.

Author: stephentoub

src/System.Collections.Immutable/tests/ImmutableArrayBuilderTest.cs

@@ -129,6 +129,21 @@ public void AddRangeImmutableArray()
 
             builder1.AddRange(array);
             Assert.Equal(new[] { 1, 2, 3 }, builder1);
+
+            Assert.Throws<ArgumentNullException>(() => builder1.AddRange((int[])null));
+            Assert.Throws<ArgumentNullException>(() => builder1.AddRange(null, 42));
+            Assert.Throws<ArgumentOutOfRangeException>(() => builder1.AddRange(new int[0], -1));
+            Assert.Throws<IndexOutOfRangeException>(() => builder1.AddRange(new int[0], 42));
+
+            Assert.Throws<ArgumentNullException>(() => builder1.AddRange((ImmutableArray<int>.Builder)null));
+            Assert.Throws<ArgumentNullException>(() => builder1.AddRange((IEnumerable<int>)null));
+
+            Assert.Throws<NullReferenceException>(() => builder1.AddRange(default(ImmutableArray<int>)));
+            builder1.AddRange(default(ImmutableArray<int>), 42);
+
+            var builder2 = new ImmutableArray<object>.Builder();
+            builder2.AddRange(default(ImmutableArray<string>));
+            Assert.Throws<ArgumentNullException>(() => builder2.AddRange((ImmutableArray<string>.Builder)null));
         }
 
         [Fact]
@@ -406,6 +421,20 @@ public void ToImmutable()
             Assert.True(builder.ToImmutable().IsEmpty);
         }
 
+        [Fact]
+        public void CopyTo()
+        {
+            var builder = ImmutableArray.Create(1, 2, 3).ToBuilder();
+            var target = new int[4];
+
+            builder.CopyTo(target, 1);
+            Assert.Equal(new[] { 0, 1, 2, 3 }, target);
+
+            Assert.Throws<ArgumentNullException>(() => builder.CopyTo(null, 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => builder.CopyTo(target, -1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => builder.CopyTo(target, 2));
+        }
+
         [Fact]
         public void Clear()
         {

src/System.Collections.Immutable/tests/ImmutableArrayTest.cs

@@ -19,10 +19,19 @@ public class ImmutableArrayTest : SimpleElementImmutablesTestBase
         private static readonly ImmutableArray<GenericParameterHelper> s_oneElementRefType = ImmutableArray.Create(new GenericParameterHelper(1));
         private static readonly ImmutableArray<string> s_twoElementRefTypeWithNull = ImmutableArray.Create("1", null);
 
+        [Fact]
+        public void Clear()
+        {
+            Assert.Equal(ImmutableArray<int>.Empty, ImmutableArray.Create<int>().Clear());
+            Assert.Equal(ImmutableArray<int>.Empty, ImmutableArray.Create<int>(1).Clear());
+            Assert.Equal(ImmutableArray<int>.Empty, ImmutableArray.Create<int>(1, 2, 3).Clear());
+        }
+
         [Fact]
         public void CreateEmpty()
         {
-            Assert.Equal(ImmutableArray.Create<int>(), ImmutableArray<int>.Empty);
+            Assert.Equal(ImmutableArray<int>.Empty, ImmutableArray.Create<int>());
+            Assert.Equal(ImmutableArray<int>.Empty, ImmutableArray.Create<int>(new int[0]));
         }
 
         [Fact]
@@ -534,12 +543,17 @@ public void ObjectEnumerator()
             enumerator = ((IEnumerable<int>)s_manyElements).GetEnumerator();
             Assert.Throws<InvalidOperationException>(() => enumerator.Current);
 
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(1, enumerator.Current);
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(2, enumerator.Current);
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(3, enumerator.Current);
+            for (int i = 0; i < 2; i++)
+            {
+                Assert.True(enumerator.MoveNext());
+                Assert.Equal(1, enumerator.Current);
+                Assert.True(enumerator.MoveNext());
+                Assert.Equal(2, enumerator.Current);
+                Assert.True(enumerator.MoveNext());
+                Assert.Equal(3, enumerator.Current);
+                if (i == 0)
+                    enumerator.Reset();
+            }
 
             Assert.False(enumerator.MoveNext());
             Assert.Throws<InvalidOperationException>(() => enumerator.Current);
@@ -641,6 +655,9 @@ public void AddRange()
 
             Assert.Equal(new[] { 1, 2, 3, 4 }, s_manyElements.AddRange(new[] { 4 }));
             Assert.Equal(new[] { 1, 2, 3, 4, 5 }, s_manyElements.AddRange(new[] { 4, 5 }));
+
+            Assert.Equal(new[] { 1, 2, 3, 4 }, s_manyElements.AddRange(ImmutableArray.Create(4)));
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, s_manyElements.AddRange(ImmutableArray.Create(4, 5)));
         }
 
         [Fact]
@@ -727,6 +744,8 @@ public void InsertRangeEmpty()
             Assert.Equal(s_manyElements, s_manyElements.InsertRange(0, Enumerable.Empty<int>()));
             Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.InsertRange(1, s_oneElement));
             Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.InsertRange(-1, s_oneElement));
+            Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.InsertRange(1, (IEnumerable<int>)s_oneElement));
+            Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.InsertRange(-1, (IEnumerable<int>)s_oneElement));
         }
 
         [Fact]
@@ -795,6 +814,14 @@ public void InsertRangeRight()
             Assert.Equal(new[] { 1, 2, 3, 7, 8 }, s_manyElements.InsertRange(3, new[] { 7, 8 }));
         }
 
+        [Fact]
+        public void InsertRangeImmutableArray()
+        {
+            Assert.Equal(new[] { 7, 8, 1, 2, 3 }, s_manyElements.InsertRange(0, ImmutableArray.Create(7, 8)));
+            Assert.Equal(new[] { 1, 7, 2, 3 }, s_manyElements.InsertRange(1, ImmutableArray.Create(7)));
+            Assert.Equal(new[] { 1, 2, 3, 7 }, s_manyElements.InsertRange(3, ImmutableArray.Create(7)));
+        }
+
         [Fact]
         public void RemoveAt()
         {
@@ -960,6 +987,20 @@ public void CopyToArray()
             }
         }
 
+        [Fact]
+        public void CopyToArrayInt()
+        {
+            var source = ImmutableArray.Create(1, 2, 3);
+            var target = new int[4];
+            source.CopyTo(target, 1);
+            Assert.Equal(new[] { 0, 1, 2, 3 }, target);
+
+            Assert.Throws<NullReferenceException>(() => s_emptyDefault.CopyTo(target, 0));
+            Assert.Throws<ArgumentNullException>(() => source.CopyTo(null, 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => source.CopyTo(target, -1));
+            Assert.Throws<ArgumentException>(() => source.CopyTo(target, 2));
+        }
+
         [Fact]
         public void CopyToIntArrayIntInt()
         {
@@ -1068,6 +1109,7 @@ public void SortRange()
         {
             var array = ImmutableArray.Create(2, 4, 1, 3);
             Assert.Throws<ArgumentOutOfRangeException>(() => array.Sort(-1, 2, Comparer<int>.Default));
+            Assert.Throws<ArgumentOutOfRangeException>(() => array.Sort(1, -1, Comparer<int>.Default));
             Assert.Throws<ArgumentOutOfRangeException>(() => array.Sort(1, 4, Comparer<int>.Default));
             Assert.Equal(new int[] { 2, 4, 1, 3 }, array.Sort(array.Length, 0, Comparer<int>.Default));
             Assert.Equal(new[] { 2, 1, 4, 3 }, array.Sort(1, 2, Comparer<int>.Default));
@@ -1221,13 +1263,40 @@ public void StructuralComparableArrayInterop()
             Assert.Equal(array.CompareTo(equalArray, Comparer<int>.Default), immArray.CompareTo(equalArray, Comparer<int>.Default));
         }
 
-        [Fact]
-        public void BinarySearch()
+        [Theory]
+        [InlineData(new int[0], 5)]
+        [InlineData(new int[] { 3 }, 5)]
+        [InlineData(new int[] { 5 }, 5)]
+        [InlineData(new int[] { 1, 2, 3 }, 1)]
+        [InlineData(new int[] { 1, 2, 3 }, 2)]
+        [InlineData(new int[] { 1, 2, 3 }, 3)]
+        [InlineData(new int[] { 1, 2, 3, 4 }, 4)]
+        public void BinarySearch(int[] array, int value)
         {
-            Assert.Throws<ArgumentNullException>(() => Assert.Equal(Array.BinarySearch(new int[0], 5), ImmutableArray.BinarySearch(default(ImmutableArray<int>), 5)));
-            Assert.Equal(Array.BinarySearch(new int[0], 5), ImmutableArray.BinarySearch(ImmutableArray.Create<int>(), 5));
-            Assert.Equal(Array.BinarySearch(new int[] { 3 }, 5), ImmutableArray.BinarySearch(ImmutableArray.Create(3), 5));
-            Assert.Equal(Array.BinarySearch(new int[] { 5 }, 5), ImmutableArray.BinarySearch(ImmutableArray.Create(5), 5));
+            Assert.Throws<ArgumentNullException>(() => ImmutableArray.BinarySearch(default(ImmutableArray<int>), value));
+
+            Assert.Equal(
+                Array.BinarySearch(array, value), 
+                ImmutableArray.BinarySearch(ImmutableArray.Create(array), value));
+
+            Assert.Equal(
+                Array.BinarySearch(array, value, Comparer<int>.Default), 
+                ImmutableArray.BinarySearch(ImmutableArray.Create(array), value, Comparer<int>.Default));
+
+            Assert.Equal(
+                Array.BinarySearch(array, 0, array.Length, value),
+                ImmutableArray.BinarySearch(ImmutableArray.Create(array), 0, array.Length, value));
+
+            if (array.Length > 0)
+            {
+                Assert.Equal(
+                    Array.BinarySearch(array, 1, array.Length - 1, value),
+                    ImmutableArray.BinarySearch(ImmutableArray.Create(array), 1, array.Length - 1, value));
+            }
+
+            Assert.Equal(
+                Array.BinarySearch(array, 0, array.Length, value, Comparer<int>.Default),
+                ImmutableArray.BinarySearch(ImmutableArray.Create(array), 0, array.Length, value, Comparer<int>.Default));
         }
 
         [Fact]

src/System.Collections.Immutable/tests/IndexOfTests.cs

@@ -95,6 +95,7 @@ public static void LastIndexOfTest<TCollection>(
             Assert.Throws<ArgumentOutOfRangeException>(() => lastIndexOfItemIndexCountEQ(emptyCollection, 100, -1, 1, new CustomComparer(50)));
             Assert.Throws<ArgumentOutOfRangeException>(() => lastIndexOfItemIndexCountEQ(collection1256, 100, 1, 20, new CustomComparer(1)));
             Assert.Throws<ArgumentOutOfRangeException>(() => lastIndexOfItemIndexCountEQ(collection1256, 100, 1, -1, new CustomComparer(1)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => lastIndexOfItemIndex(collection1256, 2, 5));
 
             Assert.Equal(-1, lastIndexOfItem(emptyCollection, 5));
             Assert.Equal(-1, lastIndexOfItemEQ(emptyCollection, 5, EqualityComparer<int>.Default));