Merge dev (#9)

* Upgrade to MSTest SDK v17

* Drop < .Net 6.0

* Improve CI, impl build-config matrix, drop < .NET 6.0

* Update GH workflow

* Fix CI workflow

* Random filters by exclusions

Author: jburnett

.github/workflows/dotnet-core.yml

@@ -1,10 +1,11 @@
-name: .NET Core Builds
+name: .NET CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [ "*" ]
   pull_request:
-    branches: [ dev ]
+    branches: [ master ]
+
 
 jobs:
   build:
@@ -15,14 +16,14 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Setup .NET 6.0
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: 6.0.100
-    - name: Install dependencies
+        dotnet-version: 6.0.x
+    - name: Restore dependencies
       run: dotnet restore
-    - name: Build Mutant
+    - name: Build
       run: dotnet build --configuration ${{ matrix.build-config }} --no-restore
-    - name: Test Mutant
+    - name: Test
       run: dotnet test --configuration ${{ matrix.build-config }} --no-restore --verbosity normal ./test/test.csproj

AMT.LinqExtensions/Exceptions.cs

@@ -0,0 +1,10 @@
+namespace AMT.LinqExtensions
+{
+	public class AllElementsExcluded : System.Exception
+	{
+		public AllElementsExcluded(string message = DEFAULT_MESSAGE) : base(message) {}
+
+
+		private const string DEFAULT_MESSAGE = "No unexcluded elements remain.";
+	}
+}

AMT.LinqExtensions/LinqExtensions.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -15,25 +14,48 @@ public static class LinqRandomizer
 
 		#region Public LINQ methods
 
-		///<summary>Returns a random element from a collection</summary>
-		///<typeparam name="T">The element type of the collection</typeparam>
-		///<param cref="elements">An ICollection of the specified type <seealso cref="T" /></param>
-		///<exception cref="System.ArgumentOutOfRangeException">Thrown when the list is empty</exception>
-		public static T Random<T> (this ICollection<T> elements)
+		///<summary>Returns a random element from a collection.</summary>
+		///<typeparam name="T">The element type of the collection.</typeparam>
+		///<param cref="elements">An ICollection of the specified type <seealso cref="T" />.</param>
+		///<exception cref="System.ArgumentOutOfRangeException">Thrown if the ICollection is empty.</exception>
+		///<exception cref="AMT.LinqExtensions.AllElementsExcluded">Thrown if all elements have been excluded.</exception>
+		public static T Random<T> (this ICollection<T> elements, IEnumerable<T> exclusions = null)
 		{
 			// Delegate to overload taking IEnumerable 
-			return Random<T>(elements as IEnumerable<T>);
+			return Random<T>(elements as IEnumerable<T>, exclusions);
 		}
 
-		///<summary>Returns a random element using an enumerable</summary>
-		///<typeparam name="T">The element type of the enumerable</typeparam>
-		///<param cref="elements">An IEnumerable of the specified type <seealso cref="T" /></param>
-		///<exception cref="System.ArgumentOutOfRangeException">Thrown when the list is empty</exception>
-		public static T Random<T> (this IEnumerable<T> elements)
+
+		///<summary>Returns a random element using an enumerable.</summary>
+		///<typeparam name="T">The element type of the enumerable.</typeparam>
+		///<param cref="elements">An IEnumerable of the specified type <seealso cref="T" />.</param>
+		///<exception cref="System.ArgumentOutOfRangeException">Thrown if the IEnumerable is empty.</exception>
+		///<exception cref="AMT.LinqExtensions.AllElementsExcluded">Thrown if all elements have been excluded.</exception>
+		public static T Random<T>(this IEnumerable<T> elements, IEnumerable<T> exclusions = null)
 		{
-			return elements.ElementAt(_randomizer.Next(0, elements.Count() - 1));
+			exclusions ??= new List<T>();
+
+			T result;
+			int iterations = 0;
+			do
+			{
+				result = elements.ElementAt(_randomizer.Next(0, elements.Count() - 1));
+				++iterations;
+			} while (exclusions.Contains<T>(result) && iterations < elements.Count());
+
+			// TODO: this approach assumes that each element has been considered. If the randomizer
+			//	repeats some values, not all elements will be considered.
+			
+			// Reached the end of the collection (possibly) without finding an element that is not excluded.
+			if (iterations == elements.Count() && exclusions.Contains(result))
+			{
+				throw new AllElementsExcluded();
+			}
+
+			return result;
 		}
 
+
 		#endregion Public LINQ methods
 	}
 

common.props

@@ -10,7 +10,7 @@
 
     <!-- Assembly version & attribute controls -->
     <PropertyGroup>
-        <VersionPrefix>4.0.0</VersionPrefix>
+        <VersionPrefix>4.1.0</VersionPrefix>
 
         <GenerateAssemblyConfigurationAttribute>true</GenerateAssemblyConfigurationAttribute>
         <GenerateAssemblyCompanyAttribute>true</GenerateAssemblyCompanyAttribute>

test/IntListRandomizerTests.cs

@@ -129,6 +129,29 @@ public void verify_excp_on_empty_list()
 			act.Should().Throw<ArgumentOutOfRangeException>();
 		}
 
+
+		[Fact]
+		public void verify_excp_after_all_excluded()
+		{
+			// Build a list and copy it to exclusions
+			List<string> list = new List<string>();
+			list.Add("one");
+			list.Add("two");
+			string[] exclusions = new string[list.Count];
+			list.CopyTo(exclusions);
+
+			// Since all the list values will be excluded, the
+			//	exception will occur.
+
+			// Test via the method taking ICollection
+			Action act = () => list.Random(exclusions);
+			act.Should().Throw<AllElementsExcluded>();
+
+			// Test via the method taking IEnumerable
+			act = () => (list as IEnumerable<string>).Random(exclusions);
+			act.Should().Throw<AllElementsExcluded>();
+		}
+
 		#endregion Negative tests
 
 	}

test/IntListTestFixture.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Xunit;
 
 
 namespace Test.AMT.LinqExtensions