More coverage tweaks.

Author: electricessence

source/CollectionWrapper.cs

@@ -5,7 +5,8 @@
 namespace Open.Collections;
 
 [ExcludeFromCodeCoverage]
-public class CollectionWrapper<T, TCollection> : ReadOnlyCollectionWrapper<T, TCollection>, ICollection<T>
+public class CollectionWrapper<T, TCollection>
+    : ReadOnlyCollectionWrapper<T, TCollection>, ICollection<T>, IAddMultiple<T>
 	where TCollection : class, ICollection<T>
 {
     public CollectionWrapper(TCollection source, bool owner = false)
@@ -31,10 +32,7 @@ protected virtual void AddInternal(T item)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void Add(T item) => AddInternal(item);
 
-    /// <summary>Adds more than one item.</summary>
-    /// <param name="item1">First item to add.</param>
-    /// <param name="item2">Additional item to add.</param>
-    /// <param name="items">Extended param items to add.</param>
+    /// <inheritdoc cref="IAddMultiple{T}.AddThese(T, T, T[])"/>
     public virtual void AddThese(T item1, T item2, params T[] items)
     {
         AddInternal(item1);

source/IAddMultiple.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace Open.Collections;
+public interface IAddMultiple<T>
+{
+    /// <summary>Adds more than one item.</summary>
+    /// <param name="item1">First item to add.</param>
+    /// <param name="item2">Additional item to add.</param>
+    /// <param name="items">Extended param items to add.</param>
+    void AddThese(T item1, T item2, params T[] items);
+
+    /// <summary>
+    /// Adds all the items in <paramref name="items"/> to this collection.
+    /// </summary>
+    /// <param name="items">The items to add.</param>
+    void AddRange(IEnumerable<T> items);
+}

source/Synchronized/TrackedCollectionWrapper.cs

@@ -10,7 +10,7 @@
 namespace Open.Collections.Synchronized;
 
 public class TrackedCollectionWrapper<T, TCollection>
-    : ModificationSynchronizedBase, ICollection<T>
+    : ModificationSynchronizedBase, ICollection<T>, IAddMultiple<T>
     where TCollection : class, ICollection<T>
 {
     protected TCollection InternalSource;
@@ -57,6 +57,18 @@ public void Add(T item)
             return true;
         });
 
+    /// <inheritdoc cref="IAddMultiple{T}.AddThese(T, T, T[])" />
+    public void AddThese(T item1, T item2, params T[] items)
+        => Sync!.Modifying(() => AssertIsAlive(), () =>
+        {
+            AddInternal(item1);
+            AddInternal(item2);
+            foreach (T? i in items)
+                AddInternal(i);
+            return true;
+        });
+
+    /// <inheritdoc />
     public void AddRange(IEnumerable<T> items)
     {
         if (items is null) return;

source/Synchronized/TrackedList.cs

@@ -1,15 +1,18 @@
 using Open.Threading;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Open.Collections.Synchronized;
 
 public class TrackedList<T> : TrackedCollectionWrapper<T, IList<T>>, IList<T>
 {
+    [ExcludeFromCodeCoverage]
     public TrackedList(ModificationSynchronizer? sync = null) : base(new List<T>(), sync)
     {
     }
 
+    [ExcludeFromCodeCoverage]
     public TrackedList(out ModificationSynchronizer sync) : base(new List<T>(), out sync)
     {
     }
@@ -41,16 +44,6 @@ bool changing
         return changing;
     }
 
-    public void Add(T item, T item2, params T[] items)
-        => Sync!.Modifying(() => AssertIsAlive(), () =>
-        {
-            AddInternal(item);
-            AddInternal(item2);
-            foreach (var i in items)
-                AddInternal(i);
-            return true;
-        });
-
     /// <inheritdoc />
     public int IndexOf(T item)
         => Sync!.Reading(

testing/Open.Collections.Tests/BasicCollectionTests.cs

@@ -28,6 +28,37 @@ public void Add()
         Collection.Count.Should().Be(count + 1);
     }
 
+    [Fact]
+    public void AddThese()
+    {
+        if (Collection is not IAddMultiple<int> c) return;
+        if (Collection.IsReadOnly)
+        {
+            Assert.Throws<Exception>(() => c.AddThese(1, 2, 3, 4));
+            return;
+        }
+
+        int count = Collection.Count;
+        c.AddThese(1, 2, 3, 4);
+        Collection.Count.Should().Be(count + 4);
+    }
+
+    [Fact]
+    public void AddRange()
+    {
+        if (Collection is not IAddMultiple<int> c) return;
+        var e = Enumerable.Range(1, 4);
+        if (Collection.IsReadOnly)
+        {
+            Assert.Throws<Exception>(() => c.AddRange(e));
+            return;
+        }
+
+        int count = Collection.Count;
+        c.AddRange(e);
+        Collection.Count.Should().Be(count + 4);
+    }
+
     [Fact]
     public void Clear()
     {

testing/Open.Collections.Tests/Collections/TrackedListTests.cs

@@ -0,0 +1,9 @@
+using Open.Collections.Synchronized;
+
+namespace Open.Collections.Tests.Collections;
+public class TrackedListTests : BasicListTests<TrackedList<int>>
+{
+    public TrackedListTests() : base(new())
+    {
+    }
+}