Impoved code coverage.

Author: electricessence

source/CollectionWrapper.cs

@@ -1,12 +1,14 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace Open.Collections;
 
 public class CollectionWrapper<T, TCollection> : ReadOnlyCollectionWrapper<T, TCollection>, ICollection<T>
 	where TCollection : class, ICollection<T>
 {
-	public CollectionWrapper(TCollection source, bool owner = false)
+    [ExcludeFromCodeCoverage]
+    public CollectionWrapper(TCollection source, bool owner = false)
         : base(source, owner)
 	{
 	}
@@ -17,22 +19,26 @@ public CollectionWrapper(TCollection source, bool owner = false)
     /// The underlying object used for synchronization.
     /// This is exposed to allow for more complex synchronization operations.
     /// </summary>
+    [ExcludeFromCodeCoverage]
     public object SyncRoot => Sync;
 
     #region Implementation of ICollection<T>
 
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected virtual void AddInternal(T item)
         => InternalSource.Add(item);
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     [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>
+    [ExcludeFromCodeCoverage]
     public virtual void AddThese(T item1, T item2, params T[] items)
     {
         AddInternal(item1);
@@ -47,6 +53,7 @@ public virtual void AddThese(T item1, T item2, params T[] items)
     /// An enumerable is potentially slow as it may be yielding to a process.
     /// </summary>
     /// <param name="items">The items to add.</param>
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void AddRange(IEnumerable<T> items)
 	{
@@ -55,17 +62,20 @@ public virtual void AddRange(IEnumerable<T> items)
 	}
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void Clear()
         => InternalSource.Clear();
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual bool Remove(T item)
         => InternalSource.Remove(item);
 
-	/// <inheritdoc />
-	public override bool IsReadOnly
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public override bool IsReadOnly
 		=> InternalSource.IsReadOnly;
 	#endregion
 }

source/Extensions.Generic.cs

@@ -38,7 +38,7 @@ public static void Register<T>(this ICollection<T> target, T value)
 			target.Add(value);
 	}
 
-	public static void Add<T>(this ICollection<T> target, IEnumerable<T> values)
+	public static void AddRange<T>(this ICollection<T> target, IEnumerable<T> values)
 	{
 		if (target is null) throw new ArgumentNullException(nameof(target));
 		Contract.EndContractBlock();
@@ -50,11 +50,11 @@ public static void Add<T>(this ICollection<T> target, IEnumerable<T> values)
 			target.Add(value);
 	}
 
-	public static void Add<T>(this ICollection<T> target, T a, T b, params T[] more)
+	public static void AddThese<T>(this ICollection<T> target, T a, T b, params T[] more)
 	{
 		target.Add(a);
 		target.Add(b);
-		target.Add(more);
+		target.AddRange(more);
 	}
 
 	public static int Remove<T>(this ICollection<T> target, IEnumerable<T> values)

source/Extensions.cs

@@ -203,7 +203,8 @@ public static void ForEach<T>(this IEnumerable<T> target, Action<T> closure, boo
 			closure(t);
 	}
 
-	public static void ForEach<T>(this IEnumerable<T> target, CancellationToken token, Action<T> closure)
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1068:CancellationToken parameters must come last", Justification = "Allows for simpler implementation. Other methods cover non-cancellable case.")]
+    public static void ForEach<T>(this IEnumerable<T> target, CancellationToken token, Action<T> closure)
 	{
 		if (target is null) throw new ArgumentNullException(nameof(target));
 		if (closure is null) throw new ArgumentNullException(nameof(closure));

source/ReadOnlyCollectionWrapper.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace Open.Collections;
@@ -21,51 +22,60 @@ public class ReadOnlyCollectionWrapper<T, TCollection> : DisposableBase, IReadOn
     /// And will throw <see cref="NotSupportedException"/> to prevent direct access to the source when .ExtractAndDispose() is called.
     /// </param>
     /// <exception cref="ArgumentNullException">If the <paramref name="source"/> is <see langword="null"/>.</exception>
-	public ReadOnlyCollectionWrapper(TCollection source, bool owner = false)
+    [ExcludeFromCodeCoverage]
+    public ReadOnlyCollectionWrapper(TCollection source, bool owner = false)
     {
         InternalSource = source ?? throw new ArgumentNullException(nameof(source));
         SourceOwned = owner;
     }
 
     #region Implementation of IReadOnlyCollection<T>
     /// <inheritdoc cref="ICollection&lt;T&gt;.Contains(T)" />
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual bool Contains(T item)
         => InternalSource.Contains(item);
 
-	/// <inheritdoc />
-	public virtual int Count
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public virtual int Count
 		=> InternalSource.Count;
 
-	/// <inheritdoc cref="ICollection&lt;T&gt;.IsReadOnly" />
-	public virtual bool IsReadOnly
+    /// <inheritdoc cref="ICollection&lt;T&gt;.IsReadOnly" />
+    [ExcludeFromCodeCoverage]
+    public virtual bool IsReadOnly
 		=> true;
 
-	/// <summary>
-	/// To ensure expected behavior, this returns an enumerator from the underlying collection.  Exceptions can be thrown if the collection content changes.
-	/// </summary>
-	/// <returns>An enumerator from the underlying collection.</returns>
-	public virtual IEnumerator<T> GetEnumerator() => InternalSource.GetEnumerator();
+    /// <summary>
+    /// To ensure expected behavior, this returns an enumerator from the underlying collection.  Exceptions can be thrown if the collection content changes.
+    /// </summary>
+    /// <returns>An enumerator from the underlying collection.</returns>
+    [ExcludeFromCodeCoverage]
+    public virtual IEnumerator<T> GetEnumerator() => InternalSource.GetEnumerator();
 
-	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    [ExcludeFromCodeCoverage]
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     /// <inheritdoc cref="ICollection&lt;T&gt;.CopyTo(T[], int)" />
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void CopyTo(T[] array, int arrayIndex)
         => InternalSource.CopyTo(array, arrayIndex);
     #endregion
 
     /// <inheritdoc cref="Extensions.CopyToSpan{T}(IEnumerable{T}, Span{T})"/>
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual Span<T> CopyTo(Span<T> span)
         => InternalSource.CopyToSpan(span);
 
     /// <inheritdoc cref="ISynchronizedCollection&lt;T&gt;.Export(ICollection{T})" />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void Export(ICollection<T> to)
-        => to.Add(InternalSource);
+        => to.AddRange(InternalSource);
 
     #region Dispose
+    [ExcludeFromCodeCoverage]
     protected override void OnDispose()
     {
         var source = Nullify(ref InternalSource);
@@ -86,5 +96,4 @@ public TCollection ExtractAndDispose()
 		}
 	}
 	#endregion
-
 }

source/Synchronized/LockSynchronizedCollectionWrapper.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace Open.Collections.Synchronized;
@@ -66,18 +67,20 @@ public override bool Remove(T item)
 		lock (Sync) return base.Remove(item);
 	}
 
-	#endregion
+    #endregion
 
-	/// <inheritdoc />
-	public T[] Snapshot()
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public T[] Snapshot()
 	{
 		lock (Sync) return this.ToArray();
 	}
 
-	/// <inheritdoc cref="CollectionWrapper&lt;T, TCollection&gt;" />
-	public override void Export(ICollection<T> to)
+    /// <inheritdoc cref="CollectionWrapper&lt;T, TCollection&gt;" />
+    [ExcludeFromCodeCoverage]
+    public override void Export(ICollection<T> to)
 	{
-		lock (Sync) to.Add(this);
+		lock (Sync) to.AddRange(this);
 	}
 
 	/// <summary>
@@ -103,33 +106,37 @@ public void ForEach(Action<T> action, bool useSnapshot = true)
 		}
 	}
 
-	/// <inheritdoc />
-	public override void CopyTo(T[] array, int arrayIndex)
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public override void CopyTo(T[] array, int arrayIndex)
 	{
 		lock (Sync) base.CopyTo(array, arrayIndex);
 	}
 
-	/// <summary>
-	/// Copies the results to the provided span up to its length or until the end of the results.
-	/// </summary>
-	/// <returns>
-	/// A span representing the results.
-	/// If the count was less than the target length, a new span representing the results.
-	/// Otherwise the target is returned.
-	/// </returns>
-	public override Span<T> CopyTo(Span<T> span)
+    /// <summary>
+    /// Copies the results to the provided span up to its length or until the end of the results.
+    /// </summary>
+    /// <returns>
+    /// A span representing the results.
+    /// If the count was less than the target length, a new span representing the results.
+    /// Otherwise the target is returned.
+    /// </returns>
+    [ExcludeFromCodeCoverage]
+    public override Span<T> CopyTo(Span<T> span)
 	{
 		lock (Sync) return base.CopyTo(span);
 	}
 
-	/// <inheritdoc />
-	public void Modify(Action<TCollection> action)
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public void Modify(Action<TCollection> action)
 	{
 		lock (Sync) action(InternalSource);
 	}
 
-	/// <inheritdoc />
-	public void Modify(Func<bool> condition, Action<TCollection> action)
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public void Modify(Func<bool> condition, Action<TCollection> action)
 	{
 		if (!condition()) return;
 		lock (Sync)
@@ -139,8 +146,9 @@ public void Modify(Func<bool> condition, Action<TCollection> action)
 		}
 	}
 
-	/// <inheritdoc />
-	public TResult Modify<TResult>(Func<TCollection, TResult> action)
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public TResult Modify<TResult>(Func<TCollection, TResult> action)
 	{
 		lock (Sync) return action(InternalSource);
 	}

source/Synchronized/LockSynchronizedDictionaryWrapper.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace Open.Collections.Synchronized;
@@ -11,41 +12,48 @@ public class LockSynchronizedDictionaryWrapper<TKey, TValue>
 	public LockSynchronizedDictionaryWrapper(IDictionary<TKey, TValue> dictionary) : base(dictionary) { }
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public virtual TValue this[TKey key]
     {
         get => InternalSource[key];
         set => InternalSource[key] = value;
     }
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public virtual ICollection<TKey> Keys
         => InternalSource.Keys;
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public virtual ICollection<TValue> Values
         => InternalSource.Values;
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void Add(TKey key, TValue value)
     {
         lock(Sync) InternalSource.Add(key, value);
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool ContainsKey(TKey key)
         => InternalSource.ContainsKey(key);
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual bool Remove(TKey key)
     {
         lock (Sync) return InternalSource.Remove(key);
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool TryGetValue(TKey key, out TValue value)
         => InternalSource.TryGetValue(key, out value);
 }