From 8e2537c7357dbd2cf846ebeba1d2d0c35536c606 Mon Sep 17 00:00:00 2001
From: Stuart Turner <stuart@turner-isageek.com>
Date: Fri, 24 Nov 2023 10:33:15 -0600
Subject: [PATCH 1/2] Restore `Slice` to supported operator

---
 Source/SuperLinq/Slice.cs         |  1 -
 Tests/SuperLinq.Test/SliceTest.cs | 76 +++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 1 deletion(-)
 create mode 100644 Tests/SuperLinq.Test/SliceTest.cs

diff --git a/Source/SuperLinq/Slice.cs b/Source/SuperLinq/Slice.cs
index 5d9e49ee..7128e71c 100644
--- a/Source/SuperLinq/Slice.cs
+++ b/Source/SuperLinq/Slice.cs
@@ -28,7 +28,6 @@ public static partial class SuperEnumerable
 	///     return all elements up to that point. There is no guarantee that the resulting sequence will contain the
 	///     number of elements requested - it may have anywhere from 0 to <paramref name="count"/>.
 	/// </remarks>
-	[Obsolete("Slice has been replaced by Take(Range).")]
 	public static IEnumerable<T> Slice<T>(this IEnumerable<T> source, int startIndex, int count)
 	{
 		return source.Take(startIndex..(startIndex + count));
diff --git a/Tests/SuperLinq.Test/SliceTest.cs b/Tests/SuperLinq.Test/SliceTest.cs
new file mode 100644
index 00000000..cd005540
--- /dev/null
+++ b/Tests/SuperLinq.Test/SliceTest.cs
@@ -0,0 +1,76 @@
+namespace Test;
+
+/// <summary>
+/// Verify the behavior of the Slice operator
+/// </summary>
+public class SliceTests
+{
+	/// <summary>
+	/// Verify that Slice evaluates in a lazy manner.
+	/// </summary>
+	[Fact]
+	public void TestSliceIsLazy()
+	{
+		_ = new BreakingSequence<int>().Slice(10, 10);
+	}
+
+	public static IEnumerable<object[]> GetSequences() =>
+		Enumerable.Range(1, 5)
+			.GetAllSequences()
+			.Select(x => new object[] { x });
+
+	[Theory]
+	[MemberData(nameof(GetSequences))]
+	public void TestSliceIdentity(IDisposableEnumerable<int> seq)
+	{
+		using (seq)
+		{
+			var result = seq.Slice(0, 5);
+			result.AssertSequenceEqual(1, 2, 3, 4, 5);
+		}
+	}
+
+	[Theory]
+	[MemberData(nameof(GetSequences))]
+	public void TestSliceFirstItem(IDisposableEnumerable<int> seq)
+	{
+		using (seq)
+		{
+			var result = seq.Slice(0, 1);
+			result.AssertSequenceEqual(1);
+		}
+	}
+
+	[Theory]
+	[MemberData(nameof(GetSequences))]
+	public void TestSliceLastItem(IDisposableEnumerable<int> seq)
+	{
+		using (seq)
+		{
+			var result = seq.Slice(4, 1);
+			result.AssertSequenceEqual(5);
+		}
+	}
+
+	[Theory]
+	[MemberData(nameof(GetSequences))]
+	public void TestSliceSmallerThanSequence(IDisposableEnumerable<int> seq)
+	{
+		using (seq)
+		{
+			var result = seq.Slice(1, 2);
+			result.AssertSequenceEqual(2, 3);
+		}
+	}
+
+	[Theory]
+	[MemberData(nameof(GetSequences))]
+	public void TestSliceLongerThanSequence(IDisposableEnumerable<int> seq)
+	{
+		using (seq)
+		{
+			var result = seq.Slice(3, 5);
+			result.AssertSequenceEqual(4, 5);
+		}
+	}
+}

From 02e7fc59a68ddfb549af7b85155afbf73056fa52 Mon Sep 17 00:00:00 2001
From: Stuart Turner <stuart@turner-isageek.com>
Date: Fri, 24 Nov 2023 11:00:52 -0600
Subject: [PATCH 2/2] Fix test expectations

---
 Tests/SuperLinq.Test/SliceTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Tests/SuperLinq.Test/SliceTest.cs b/Tests/SuperLinq.Test/SliceTest.cs
index cd005540..fffd7b3b 100644
--- a/Tests/SuperLinq.Test/SliceTest.cs
+++ b/Tests/SuperLinq.Test/SliceTest.cs
@@ -16,7 +16,7 @@ public void TestSliceIsLazy()
 
 	public static IEnumerable<object[]> GetSequences() =>
 		Enumerable.Range(1, 5)
-			.GetAllSequences()
+			.GetCollectionSequences()
 			.Select(x => new object[] { x });
 
 	[Theory]