More coverage tweaks.

Author: electricessence

source/ArrayPoolSegment.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Open.Collections;
 
@@ -22,13 +23,17 @@ public ArrayPoolSegment(
 
 	public void Dispose() => Pool?.Return(Segment.Array, _clear);
 
-	public static implicit operator ArraySegment<T> (ArrayPoolSegment<T> segment) => segment.Segment;
-	public static implicit operator Memory<T> (ArrayPoolSegment<T> segment) => segment.Segment;
-	public static implicit operator ReadOnlyMemory<T>(ArrayPoolSegment<T> segment) => segment.Segment;
+    [ExcludeFromCodeCoverage]
+    public static implicit operator ArraySegment<T> (ArrayPoolSegment<T> segment) => segment.Segment;
+    [ExcludeFromCodeCoverage]
+    public static implicit operator Memory<T> (ArrayPoolSegment<T> segment) => segment.Segment;
+    [ExcludeFromCodeCoverage]
+    public static implicit operator ReadOnlyMemory<T>(ArrayPoolSegment<T> segment) => segment.Segment;
 }
 
 public static class ArrayPoolExtensions
 {
+    [ExcludeFromCodeCoverage]
 	public static ArrayPoolSegment<T> RentSegment<T>(
 		this ArrayPool<T> pool,
 		int length,

source/DictionaryToHashSetWrapper.cs

@@ -9,16 +9,18 @@ public class DictionaryToHashSetWrapper<T> : ISet<T>
 {
 	protected readonly IDictionary<T, bool> InternalSource;
 
-	// ReSharper disable once MemberCanBeProtected.Global
-	public DictionaryToHashSetWrapper(IDictionary<T, bool> source)
+    [ExcludeFromCodeCoverage]
+    public DictionaryToHashSetWrapper(IDictionary<T, bool> source)
         => InternalSource = source;
 
-	/// <inheritdoc />
-	public int Count
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public int Count
 		=> InternalSource.Count;
 
-	/// <inheritdoc />
-	public bool IsReadOnly
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
+    public bool IsReadOnly
 		=> InternalSource.IsReadOnly;
 
 	/// <inheritdoc />

source/KeyValuePair.cs

@@ -1,8 +1,12 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace Open.Collections;
 
 public static class KeyValuePair
 {
-	public static KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue value) => new(key, value);
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue value) => new(key, value);
 }

source/ListWrapper.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace Open.Collections;
@@ -12,6 +13,7 @@ public ListWrapper(TList source, bool owner = false)
     }
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public virtual T this[int index]
     {
         get => InternalSource[index];
@@ -34,6 +36,7 @@ public virtual void RemoveAt(int index)
         => InternalSource.RemoveAt(index);
 }
 
+[ExcludeFromCodeCoverage]
 public class ListWrapper<T>
     : ListWrapper<T, IList<T>>
 {

source/OrderedDictionary.cs

@@ -32,9 +32,11 @@ public override TValue this[TKey key]
     }
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public override ICollection<TKey> Keys => _keys.AsReadOnly();
 
     /// <inheritdoc />
+    [ExcludeFromCodeCoverage]
     public override ICollection<TValue> Values => _values.AsReadOnly();
 
     /// <inheritdoc />

source/ReadOnlyCollectionWrapper.cs

@@ -70,6 +70,8 @@ public virtual Span<T> CopyTo(Span<T> span)
         => InternalSource.CopyToSpan(span);
 
     /// <inheritdoc cref="ISynchronizedCollection&lt;T&gt;.Export(ICollection{T})" />
+
+    [ExcludeFromCodeCoverage]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public virtual void Export(ICollection<T> to)
         => to.AddRange(InternalSource);

testing/Open.Collections.Tests/BasicCollectionTests.cs

@@ -1,6 +1,5 @@
 using FluentAssertions;
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using Xunit;

testing/Open.Collections.Tests/LazyListTests.cs

@@ -13,11 +13,24 @@ public void LazyListSmokeTest()
             System.Collections.Generic.IEnumerable<int> e = Enumerable.Range(0, 5);
 			Assert.Equal(5, e.Memoize().Count);
 			Assert.Equal(5, e.MemoizeUnsafe().Count);
+            Assert.True(e.Memoize().TryGetValueAt(1, out _));
+            Assert.False(e.Memoize().TryGetValueAt(8, out _));
+            Assert.False(e.MemoizeUnsafe().Contains(9));
 
-			Assert.Throws<InvalidOperationException>(() => e.Memoize(true).Count);
-		}
+            Assert.Throws<InvalidOperationException>(() => e.Memoize(true).IndexOf(9));
+            Assert.Throws<InvalidOperationException>(() => e.Memoize(true).Count);
+            Assert.Throws<ArgumentOutOfRangeException>(() => e.MemoizeUnsafe()[-1]);
+            Assert.Throws<ArgumentOutOfRangeException>(() => e.MemoizeUnsafe().TryGetValueAt(-1, out _));
+            Assert.Throws<ArgumentOutOfRangeException>(() => e.MemoizeUnsafe()[6]);
 
-		{
+            int i = 0;
+            foreach(int x in e.Memoize())
+            {
+                Assert.Equal(i++, x);
+            }
+        }
+
+        {
             System.Collections.Generic.IEnumerable<int> e = Enumerable.Range(0, 30);
             LazyList<int> a = e.Memoize();
             LazyListUnsafe<int> b = e.MemoizeUnsafe();

testing/Open.Collections.Tests/SubsetTests.cs

@@ -1,3 +1,4 @@
+using System.Buffers;
 using System.Collections.Immutable;
 using System.Linq;
 using Xunit;
@@ -71,11 +72,28 @@ public void TestSubset3_3()
         char[][] actual = Set3.Subsets(3).ToArray();
 		Assert.Equal(expected, actual);
 
+        actual = Set3
+            .Subsets(3, ArrayPool<char>.Shared, true)
+            .Select(Selector).ToArray();
+        Assert.Equal(expected, actual);
+
         char[][] progressive = Set3.SubsetsProgressive(3).ToArray();
 		Assert.Equal(expected, progressive);
-	}
 
-	[Fact]
+        progressive = Set3
+            .SubsetsProgressive(3, ArrayPool<char>.Shared, true)
+            .Select(Selector).ToArray();
+        Assert.Equal(expected, progressive);
+    }
+
+    static T[] Selector<T>(ArrayPoolSegment<T> e)
+    {
+        T[] a = e.Segment.ToArray();
+        e.Dispose();
+        return a;
+    }
+
+    [Fact]
 	public void TestSubset4_4()
 	{
         int[][] expected = new int[][] {
@@ -88,9 +106,19 @@ public void TestSubset4_4()
         int[][] actual = Set4.Subsets(4).ToArray();
 		Assert.Equal(expected, actual);
 
+        actual = Set4
+            .Subsets(4, ArrayPool<int>.Shared)
+            .Select(Selector).ToArray();
+        Assert.Equal(expected, actual);
+
         int[][] progressive = Set4.SubsetsProgressive(4).ToArray();
-		Assert.Equal(expected, progressive);
-	}
+        Assert.Equal(expected, progressive);
+
+        progressive = Set4
+            .SubsetsProgressive(4, ArrayPool<int>.Shared)
+            .Select(Selector).ToArray();
+        Assert.Equal(expected, progressive);
+    }
 
 	[Fact]
 	public void TestSubset4_3()