From 8e179addc367f5d208411173fc5d5ee768c18ab8 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 11:44:50 +0100
Subject: [PATCH 01/13] Add TestWindowDoNotExposeItsBuffer,
 WindowLeftDoNotExposeItsBuffer and WindowRightDoNotExposeItsBuffer.

---
 MoreLinq.Test/WindowLeftTest.cs  | 17 +++++++++++++++++
 MoreLinq.Test/WindowRightTest.cs | 17 +++++++++++++++++
 MoreLinq.Test/WindowTest.cs      | 16 ++++++++++++++++
 3 files changed, 50 insertions(+)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index d85d8f11f..827cbecfe 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -12,6 +12,23 @@ public void WindowLeftIsLazy()
             new BreakingSequence<int>().WindowLeft(1);
         }
 
+        /// <summary>
+        /// Verify that Window doesn't return it's internal buffer
+        /// </summary>
+        [Test]
+        public void WindowLeftDoNotExposeItsBuffer()
+        {
+            var sequence = Enumerable.Repeat(0, 3);
+            var expected = new[] { 0, 0, 0 };
+            var actual = sequence.WindowLeft(2).Select(l =>
+            {
+                if (l.Count > 1)
+                    l[1] = 1;
+                return l[0];
+            }).ToList();
+            CollectionAssert.AreEqual(expected, actual);
+        }
+
         [Test]
         public void WindowLeftWithNegativeWindowSize()
         {
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index 62951923c..e30eb6640 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -12,6 +12,23 @@ public void WindowRightIsLazy()
             new BreakingSequence<int>().WindowRight(1);
         }
 
+        /// <summary>
+        /// Verify that Window doesn't return it's internal buffer
+        /// </summary>
+        [Test]
+        public void WindowRightDoNotExposeItsBuffer()
+        {
+            var sequence = Enumerable.Repeat(0, 3);
+            var expected = new[] { 0, 0, 0 };
+            var actual = sequence.WindowRight(2).Select(l =>
+            {
+                if (l.Count > 1)
+                    l[1] = 1;
+                return l[0];
+            }).ToList();
+            CollectionAssert.AreEqual(expected, actual);
+        }
+
         [Test]
         public void WindowRightWithNegativeWindowSize()
         {
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 83e71e6a4..732ef9dea 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -17,6 +17,22 @@ public void TestWindowIsLazy()
             new BreakingSequence<int>().Window(1);
         }
 
+        /// <summary>
+        /// Verify that Window doesn't return it's internal buffer
+        /// </summary>
+        [Test]
+        public void TestWindowDoNotExposeItsBuffer()
+        {
+            var sequence = Enumerable.Repeat(0, 3);
+            var expected = new[] {0, 0};
+            var actual = sequence.Window(2).Select(l =>
+            {
+                l[1] = 1;
+                return l[0];
+            }).ToList();
+            CollectionAssert.AreEqual(expected, actual);
+        }
+
         /// <summary>
         /// Verify that a negative window size results in an exception
         /// </summary>

From 7cc861506289ac0069960061febc5b04a5e4429d Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 12:33:48 +0100
Subject: [PATCH 02/13] Add TestWindowOnKnownResults

---
 MoreLinq.Test/WindowTest.cs | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 732ef9dea..cb43ae2e8 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -1,3 +1,7 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework.Interfaces;
+
 namespace MoreLinq.Test
 {
     using NUnit.Framework;
@@ -41,7 +45,7 @@ public void TestWindowNegativeWindowSizeException()
         {
             var sequence = Enumerable.Repeat(1, 10);
 
-            AssertThrowsArgument.OutOfRangeException("size",() =>
+            AssertThrowsArgument.OutOfRangeException("size", () =>
                 sequence.Window(-5));
         }
 
@@ -130,5 +134,24 @@ public void TestWindowWindowsImmutability()
                 reader.ReadEnd();
             }
         }
+
+        static IEnumerable<T> Seq<T>(params T[] values) => values;
+
+        public static readonly IEnumerable<ITestCaseData> TestData =
+            from e in new[]
+            {
+                new {Source = Enumerable.Range(0, 4), Size = 1, Result = new[] {Seq(0), Seq(1), Seq(2), Seq(3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 2, Result = new[] {Seq(0, 1), Seq(1, 2), Seq(2, 3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 3, Result = new[] {Seq(0, 1, 2), Seq(1, 2, 3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 4, Result = new[] {Seq(0, 1, 2, 3)}}
+            }
+            select new TestCaseData(e.Source, e.Size).Returns(e.Result);
+
+        [Test, TestCaseSource(nameof(TestData))]
+        public IEnumerable<IEnumerable<int>> TestWindowOnKnownResults(IEnumerable<int> sequence, int sizes)
+        {
+            using var testingSequence = sequence.AsTestingSequence();
+            return testingSequence.Window(sizes).ToList();
+        }
     }
 }

From 8765b1b7a8b628e54f285a5c1936ff898e742c76 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 13:43:19 +0100
Subject: [PATCH 03/13] Renamed tests Window*DoNotExposeItsBuffer =>
 TestWindow*ReturnIsolatedList

---
 MoreLinq.Test/WindowLeftTest.cs  | 16 +++++++---------
 MoreLinq.Test/WindowRightTest.cs | 16 +++++++---------
 MoreLinq.Test/WindowTest.cs      | 16 +++++++---------
 3 files changed, 21 insertions(+), 27 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index 827cbecfe..fc7ab73c9 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -13,20 +13,18 @@ public void WindowLeftIsLazy()
         }
 
         /// <summary>
-        /// Verify that Window doesn't return it's internal buffer
+        /// Verify that elements returned by Window are isolated.
+        /// Modification on one window should not be visible from the next window.
         /// </summary>
         [Test]
-        public void WindowLeftDoNotExposeItsBuffer()
+        public void TestWindowLeftReturnIsolatedList()
         {
             var sequence = Enumerable.Repeat(0, 3);
-            var expected = new[] { 0, 0, 0 };
-            var actual = sequence.WindowLeft(2).Select(l =>
+            foreach (var window in sequence.WindowLeft(2))
             {
-                if (l.Count > 1)
-                    l[1] = 1;
-                return l[0];
-            }).ToList();
-            CollectionAssert.AreEqual(expected, actual);
+                window[window.Count - 1] = 1; // modify last item of the window
+                Assert.That(window[0], Is.EqualTo(0));
+            }
         }
 
         [Test]
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index e30eb6640..206d04ac9 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -13,20 +13,18 @@ public void WindowRightIsLazy()
         }
 
         /// <summary>
-        /// Verify that Window doesn't return it's internal buffer
+        /// Verify that elements returned by Window are isolated.
+        /// Modification on one window should not be visible from the next window.
         /// </summary>
         [Test]
-        public void WindowRightDoNotExposeItsBuffer()
+        public void TestWindowRightReturnIsolatedList()
         {
             var sequence = Enumerable.Repeat(0, 3);
-            var expected = new[] { 0, 0, 0 };
-            var actual = sequence.WindowRight(2).Select(l =>
+            foreach (var window in sequence.WindowRight(2))
             {
-                if (l.Count > 1)
-                    l[1] = 1;
-                return l[0];
-            }).ToList();
-            CollectionAssert.AreEqual(expected, actual);
+                window[window.Count - 1] = 1; // modify last item of the window
+                Assert.That(window[0], Is.EqualTo(0));
+            }
         }
 
         [Test]
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index cb43ae2e8..4a75b708a 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using NUnit.Framework.Interfaces;
 
@@ -22,19 +21,18 @@ public void TestWindowIsLazy()
         }
 
         /// <summary>
-        /// Verify that Window doesn't return it's internal buffer
+        /// Verify that elements returned by Window are isolated.
+        /// Modification on one window should not be visible from the next window.
         /// </summary>
         [Test]
-        public void TestWindowDoNotExposeItsBuffer()
+        public void TestWindowReturnIsolatedList()
         {
             var sequence = Enumerable.Repeat(0, 3);
-            var expected = new[] {0, 0};
-            var actual = sequence.Window(2).Select(l =>
+            foreach (var window in sequence.Window(2))
             {
-                l[1] = 1;
-                return l[0];
-            }).ToList();
-            CollectionAssert.AreEqual(expected, actual);
+                window[window.Count - 1] = 1; // modify last item of the window
+                Assert.That(window[0], Is.EqualTo(0));
+            }
         }
 
         /// <summary>

From 340858b6596217ad2a7426491045304f3ef4e45e Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 13:58:56 +0100
Subject: [PATCH 04/13] Fix TestWindow*ReturnIsolatedList

---
 MoreLinq.Test/WindowLeftTest.cs  | 3 ++-
 MoreLinq.Test/WindowRightTest.cs | 3 ++-
 MoreLinq.Test/WindowTest.cs      | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index fc7ab73c9..c122fa881 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -22,7 +22,8 @@ public void TestWindowLeftReturnIsolatedList()
             var sequence = Enumerable.Repeat(0, 3);
             foreach (var window in sequence.WindowLeft(2))
             {
-                window[window.Count - 1] = 1; // modify last item of the window
+                if (window.Count > 1)
+                    window[1] = 1;
                 Assert.That(window[0], Is.EqualTo(0));
             }
         }
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index 206d04ac9..b8dd2260b 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -22,7 +22,8 @@ public void TestWindowRightReturnIsolatedList()
             var sequence = Enumerable.Repeat(0, 3);
             foreach (var window in sequence.WindowRight(2))
             {
-                window[window.Count - 1] = 1; // modify last item of the window
+                if (window.Count > 1)
+                    window[1] = 1;
                 Assert.That(window[0], Is.EqualTo(0));
             }
         }
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 4a75b708a..3553ce95a 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -30,7 +30,7 @@ public void TestWindowReturnIsolatedList()
             var sequence = Enumerable.Repeat(0, 3);
             foreach (var window in sequence.Window(2))
             {
-                window[window.Count - 1] = 1; // modify last item of the window
+                window[1] = 1;
                 Assert.That(window[0], Is.EqualTo(0));
             }
         }

From e41a21d3a4a49e18d8f439d793a0c43b911b26b7 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 14:02:40 +0100
Subject: [PATCH 05/13] Window* methods returned elements that are not isolated
 from each other.

---
 MoreLinq/Window.cs      | 21 ++++++++++++---------
 MoreLinq/WindowLeft.cs  |  9 +++++++--
 MoreLinq/WindowRight.cs |  5 ++++-
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs
index c377f90d3..ed32f6b1d 100644
--- a/MoreLinq/Window.cs
+++ b/MoreLinq/Window.cs
@@ -52,19 +52,22 @@ public static IEnumerable<IList<TSource>> Window<TSource>(this IEnumerable<TSour
                 if (i < size)
                     yield break;
 
-                // return the first window (whatever size it may be)
-                yield return window;
-
-                // generate the next window by shifting forward by one item
-                while (iter.MoveNext())
+                for(;;)
                 {
-                    // NOTE: If we used a circular queue rather than a list,
-                    //       we could make this quite a bit more efficient.
-                    //       Sadly the BCL does not offer such a collection.
+                    if (!iter.MoveNext())
+                    {
+                        // return the last window.
+                        yield return window;
+                        yield break;
+                    }
+
+                    // generate the next window by shifting forward by one item
+                    // and do that before exposing the data
                     var newWindow = new TSource[size];
                     Array.Copy(window, 1, newWindow, 0, size - 1);
                     newWindow[size - 1] = iter.Current;
-                    yield return newWindow;
+
+                    yield return window;
                     window = newWindow;
                 }
             }
diff --git a/MoreLinq/WindowLeft.cs b/MoreLinq/WindowLeft.cs
index 3365e768d..fdcd72803 100644
--- a/MoreLinq/WindowLeft.cs
+++ b/MoreLinq/WindowLeft.cs
@@ -71,13 +71,18 @@ public static IEnumerable<IList<TSource>> WindowLeft<TSource>(this IEnumerable<T
                     window.Add(item);
                     if (window.Count < size)
                         continue;
+
+                    // prepare next window before exposing data
+                    var nextWindow = new List<TSource>(window.Skip(1));
                     yield return window;
-                    window = new List<TSource>(window.Skip(1));
+                    window = nextWindow;
                 }
                 while (window.Count > 0)
                 {
+                    // prepare next window before exposing data
+                    var nextWindow = new List<TSource>(window.Skip(1));
                     yield return window;
-                    window = new List<TSource>(window.Skip(1));
+                    window = nextWindow;
                 }
             }
         }
diff --git a/MoreLinq/WindowRight.cs b/MoreLinq/WindowRight.cs
index 9f9d76a91..4172c3d6d 100644
--- a/MoreLinq/WindowRight.cs
+++ b/MoreLinq/WindowRight.cs
@@ -84,8 +84,11 @@ static IEnumerable<IList<TSource>> WindowRightWhile<TSource>(
                 foreach (var item in source)
                 {
                     window.Add(item);
+
+                    // prepare next window before exposing data
+                    var nextWindow = new List<TSource>(predicate(item, window.Count) ? window : window.Skip(1));
                     yield return window;
-                    window = new List<TSource>(predicate(item, window.Count) ? window : window.Skip(1));
+                    window = nextWindow;
                 }
             }
         }

From 2ca1b7ab5a22b3a3c1cb62e70a469250665da180 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 14:27:13 +0100
Subject: [PATCH 06/13] Add TestWindowLeftOnKnownResults and
 TestWindowRightOnKnownResults

---
 MoreLinq.Test/WindowLeftTest.cs  | 22 ++++++++++++++++++++++
 MoreLinq.Test/WindowRightTest.cs | 22 ++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index c122fa881..ad02c2ae6 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -1,3 +1,5 @@
+using NUnit.Framework.Interfaces;
+
 namespace MoreLinq.Test
 {
     using System.Collections.Generic;
@@ -92,5 +94,25 @@ public void WindowLeftWithWindowSizeSmallerThanSequence()
                 reader.ReadEnd();
             }
         }
+
+        static IEnumerable<T> Seq<T>(params T[] values) => values;
+
+        public static readonly IEnumerable<ITestCaseData> TestData =
+            from e in new[]
+            {
+                new {Source = Enumerable.Range(0, 4), Size = 1, Result = new[] {Seq(0), Seq(1), Seq(2), Seq(3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 2, Result = new[] {Seq(0, 1), Seq(1, 2), Seq(2, 3), Seq(3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 3, Result = new[] {Seq(0, 1, 2), Seq(1, 2, 3), Seq(2, 3), Seq(3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 4, Result = new[] {Seq(0, 1, 2, 3), Seq(1, 2, 3), Seq(2, 3), Seq(3)}}
+            }
+            select new TestCaseData(e.Source, e.Size).Returns(e.Result);
+
+        [Test, TestCaseSource(nameof(TestData))]
+        public IEnumerable<IEnumerable<int>> TestWindowLeftOnKnownResults(IEnumerable<int> sequence, int sizes)
+        {
+            using var testingSequence = sequence.AsTestingSequence();
+            var r = testingSequence.WindowLeft(sizes).ToList();
+            return r;
+        }
     }
 }
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index b8dd2260b..8465e492d 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -1,3 +1,5 @@
+using NUnit.Framework.Interfaces;
+
 namespace MoreLinq.Test
 {
     using System.Collections.Generic;
@@ -92,5 +94,25 @@ public void WindowRightWithWindowSizeSmallerThanSequence()
                 reader.ReadEnd();
             }
         }
+
+        static IEnumerable<T> Seq<T>(params T[] values) => values;
+
+        public static readonly IEnumerable<ITestCaseData> TestData =
+            from e in new[]
+            {
+                new {Source = Enumerable.Range(0, 4), Size = 1, Result = new[] {Seq(0), Seq(1), Seq(2), Seq(3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 2, Result = new[] {Seq(0), Seq(0, 1), Seq(1, 2), Seq(2, 3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 3, Result = new[] {Seq(0), Seq(0, 1), Seq(0, 1, 2), Seq(1, 2, 3)}},
+                new {Source = Enumerable.Range(0, 4), Size = 4, Result = new[] {Seq(0), Seq(0, 1), Seq(0, 1, 2), Seq(0, 1, 2, 3)}}
+            }
+            select new TestCaseData(e.Source, e.Size).Returns(e.Result);
+
+        [Test, TestCaseSource(nameof(TestData))]
+        public IEnumerable<IEnumerable<int>> TestWindowRightOnKnownResults(IEnumerable<int> sequence, int sizes)
+        {
+            using var testingSequence = sequence.AsTestingSequence();
+            var r = testingSequence.WindowRight(sizes).ToList();
+            return r;
+        }
     }
 }

From 6c0de36956e2163661efebc9f3ec69704f3b1e40 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 18:40:58 +0100
Subject: [PATCH 07/13] Added some test for Window(Left|Right):  -
 ModifyWindowBeforeMoveNextDoNotAffectNextWindow  -
 ModifyWindowAfterMoveNextDoNotAffectNextWindow  -
 ModifyWindowBeforeMoveNextDoNotAffectPrevWindow

---
 MoreLinq.Test/WindowLeftTest.cs  | 53 ++++++++++++++++++++++++--------
 MoreLinq.Test/WindowRightTest.cs | 53 ++++++++++++++++++++++++--------
 MoreLinq.Test/WindowTest.cs      | 52 ++++++++++++++++++++++++-------
 3 files changed, 123 insertions(+), 35 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index c122fa881..bdc3909a7 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -12,20 +12,49 @@ public void WindowLeftIsLazy()
             new BreakingSequence<int>().WindowLeft(1);
         }
 
-        /// <summary>
-        /// Verify that elements returned by Window are isolated.
-        /// Modification on one window should not be visible from the next window.
-        /// </summary>
         [Test]
-        public void TestWindowLeftReturnIsolatedList()
+        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
         {
-            var sequence = Enumerable.Repeat(0, 3);
-            foreach (var window in sequence.WindowLeft(2))
-            {
-                if (window.Count > 1)
-                    window[1] = 1;
-                Assert.That(window[0], Is.EqualTo(0));
-            }
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.WindowLeft(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            window1[1] = -1;
+            e.MoveNext();
+            var window2 = e.Current;
+
+            Assert.That(window2[0], Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
+        {
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.WindowLeft(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            e.MoveNext();
+            window1[1] = -1;
+            var window2 = e.Current;
+
+            Assert.That(window2[0], Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ModifyWindowBeforeMoveNextDoNotAffectPrevWindow()
+        {
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.WindowLeft(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            e.MoveNext();
+            var window2 = e.Current;
+            window2[0] = -1;
+
+            Assert.That(window1[1], Is.EqualTo(1));
         }
 
         [Test]
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index b8dd2260b..6e0aa734d 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -12,20 +12,49 @@ public void WindowRightIsLazy()
             new BreakingSequence<int>().WindowRight(1);
         }
 
-        /// <summary>
-        /// Verify that elements returned by Window are isolated.
-        /// Modification on one window should not be visible from the next window.
-        /// </summary>
         [Test]
-        public void TestWindowRightReturnIsolatedList()
+        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
         {
-            var sequence = Enumerable.Repeat(0, 3);
-            foreach (var window in sequence.WindowRight(2))
-            {
-                if (window.Count > 1)
-                    window[1] = 1;
-                Assert.That(window[0], Is.EqualTo(0));
-            }
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.WindowRight(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            window1[0] = -1;
+            e.MoveNext();
+            var window2 = e.Current;
+
+            Assert.That(window2[0], Is.EqualTo(0));
+        }
+
+        [Test]
+        public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
+        {
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.WindowRight(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            e.MoveNext();
+            window1[0] = -1;
+            var window2 = e.Current;
+
+            Assert.That(window2[0], Is.EqualTo(0));
+        }
+
+        [Test]
+        public void ModifyWindowBeforeMoveNextDoNotAffectPrevWindow()
+        {
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.WindowRight(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            e.MoveNext();
+            var window2 = e.Current;
+            window2[0] = -1;
+
+            Assert.That(window1[0], Is.EqualTo(0));
         }
 
         [Test]
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 3553ce95a..274f096ed 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -20,19 +20,49 @@ public void TestWindowIsLazy()
             new BreakingSequence<int>().Window(1);
         }
 
-        /// <summary>
-        /// Verify that elements returned by Window are isolated.
-        /// Modification on one window should not be visible from the next window.
-        /// </summary>
         [Test]
-        public void TestWindowReturnIsolatedList()
+        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
         {
-            var sequence = Enumerable.Repeat(0, 3);
-            foreach (var window in sequence.Window(2))
-            {
-                window[1] = 1;
-                Assert.That(window[0], Is.EqualTo(0));
-            }
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.Window(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            window1[1] = -1;
+            e.MoveNext();
+            var window2 = e.Current;
+
+            Assert.That(window2[0], Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
+        {
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.Window(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            e.MoveNext();
+            window1[1] = -1;
+            var window2 = e.Current;
+
+            Assert.That(window2[0], Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ModifyWindowBeforeMoveNextDoNotAffectPrevWindow()
+        {
+            var sequence = Enumerable.Range(0, 3);
+            using var e = sequence.Window(2).GetEnumerator();
+
+            e.MoveNext();
+            var window1 = e.Current;
+            e.MoveNext();
+            var window2 = e.Current;
+            window2[0] = -1;
+
+            Assert.That(window1[1], Is.EqualTo(1));
         }
 
         /// <summary>

From d221ceae0b6d7da98b0cab59e4dcb2bc8288138b Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 18:48:56 +0100
Subject: [PATCH 08/13] Rename ModifyWindowBeforeMoveNextDoNotAffectPrevWindow 
 to ModifyWindowDoNotAffectPrevWindow

---
 MoreLinq.Test/WindowLeftTest.cs  | 2 +-
 MoreLinq.Test/WindowRightTest.cs | 2 +-
 MoreLinq.Test/WindowTest.cs      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index 9265cd31a..ae14934d6 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -45,7 +45,7 @@ public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowBeforeMoveNextDoNotAffectPrevWindow()
+        public void ModifyWindowDoNotAffectPrevWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowLeft(2).GetEnumerator();
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index f92c5fbdb..87c995119 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -45,7 +45,7 @@ public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowBeforeMoveNextDoNotAffectPrevWindow()
+        public void ModifyWindowDoNotAffectPrevWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowRight(2).GetEnumerator();
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 274f096ed..83eecf9eb 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -51,7 +51,7 @@ public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowBeforeMoveNextDoNotAffectPrevWindow()
+        public void ModifyWindowDoNotAffectPrevWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.Window(2).GetEnumerator();

From 5598a8da2c0208a23eddfdfc7c257db68dd73400 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Wed, 6 Nov 2019 19:08:58 +0100
Subject: [PATCH 09/13] Simplify Window implementation

---
 MoreLinq/Window.cs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs
index ed32f6b1d..018f25b16 100644
--- a/MoreLinq/Window.cs
+++ b/MoreLinq/Window.cs
@@ -52,15 +52,8 @@ public static IEnumerable<IList<TSource>> Window<TSource>(this IEnumerable<TSour
                 if (i < size)
                     yield break;
 
-                for(;;)
+                while(iter.MoveNext())
                 {
-                    if (!iter.MoveNext())
-                    {
-                        // return the last window.
-                        yield return window;
-                        yield break;
-                    }
-
                     // generate the next window by shifting forward by one item
                     // and do that before exposing the data
                     var newWindow = new TSource[size];
@@ -70,6 +63,9 @@ public static IEnumerable<IList<TSource>> Window<TSource>(this IEnumerable<TSour
                     yield return window;
                     window = newWindow;
                 }
+
+                // return the last window.
+                yield return window;
             }
         }
 

From cc21cc4f55b1cc946e3ad0d25b4676bf355f04b8 Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Fri, 8 Nov 2019 19:39:11 +0100
Subject: [PATCH 10/13] Clean-up tests

---
 MoreLinq.Test/WindowLeftTest.cs  | 38 ++++++++++++++-----------------
 MoreLinq.Test/WindowRightTest.cs | 38 ++++++++++++++-----------------
 MoreLinq.Test/WindowTest.cs      | 39 +++++++++++++++-----------------
 3 files changed, 52 insertions(+), 63 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index ae14934d6..faa2da355 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -1,9 +1,25 @@
-using NUnit.Framework.Interfaces;
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2008 Jonathan Skeet. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
 
 namespace MoreLinq.Test
 {
     using System.Collections.Generic;
     using NUnit.Framework;
+    using NUnit.Framework.Interfaces;
 
     [TestFixture]
     public class WindowLeftTest
@@ -123,25 +139,5 @@ public void WindowLeftWithWindowSizeSmallerThanSequence()
                 reader.ReadEnd();
             }
         }
-
-        static IEnumerable<T> Seq<T>(params T[] values) => values;
-
-        public static readonly IEnumerable<ITestCaseData> TestData =
-            from e in new[]
-            {
-                new {Source = Enumerable.Range(0, 4), Size = 1, Result = new[] {Seq(0), Seq(1), Seq(2), Seq(3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 2, Result = new[] {Seq(0, 1), Seq(1, 2), Seq(2, 3), Seq(3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 3, Result = new[] {Seq(0, 1, 2), Seq(1, 2, 3), Seq(2, 3), Seq(3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 4, Result = new[] {Seq(0, 1, 2, 3), Seq(1, 2, 3), Seq(2, 3), Seq(3)}}
-            }
-            select new TestCaseData(e.Source, e.Size).Returns(e.Result);
-
-        [Test, TestCaseSource(nameof(TestData))]
-        public IEnumerable<IEnumerable<int>> TestWindowLeftOnKnownResults(IEnumerable<int> sequence, int sizes)
-        {
-            using var testingSequence = sequence.AsTestingSequence();
-            var r = testingSequence.WindowLeft(sizes).ToList();
-            return r;
-        }
     }
 }
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index 87c995119..2dfcfb1b9 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -1,9 +1,25 @@
-using NUnit.Framework.Interfaces;
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2008 Jonathan Skeet. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
 
 namespace MoreLinq.Test
 {
     using System.Collections.Generic;
     using NUnit.Framework;
+    using NUnit.Framework.Interfaces;
 
     [TestFixture]
     public class WindowRightTest
@@ -123,25 +139,5 @@ public void WindowRightWithWindowSizeSmallerThanSequence()
                 reader.ReadEnd();
             }
         }
-
-        static IEnumerable<T> Seq<T>(params T[] values) => values;
-
-        public static readonly IEnumerable<ITestCaseData> TestData =
-            from e in new[]
-            {
-                new {Source = Enumerable.Range(0, 4), Size = 1, Result = new[] {Seq(0), Seq(1), Seq(2), Seq(3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 2, Result = new[] {Seq(0), Seq(0, 1), Seq(1, 2), Seq(2, 3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 3, Result = new[] {Seq(0), Seq(0, 1), Seq(0, 1, 2), Seq(1, 2, 3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 4, Result = new[] {Seq(0), Seq(0, 1), Seq(0, 1, 2), Seq(0, 1, 2, 3)}}
-            }
-            select new TestCaseData(e.Source, e.Size).Returns(e.Result);
-
-        [Test, TestCaseSource(nameof(TestData))]
-        public IEnumerable<IEnumerable<int>> TestWindowRightOnKnownResults(IEnumerable<int> sequence, int sizes)
-        {
-            using var testingSequence = sequence.AsTestingSequence();
-            var r = testingSequence.WindowRight(sizes).ToList();
-            return r;
-        }
     }
 }
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 83eecf9eb..71947291f 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -1,9 +1,25 @@
-using System.Collections.Generic;
-using NUnit.Framework.Interfaces;
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2008 Jonathan Skeet. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
 
 namespace MoreLinq.Test
 {
+    using System.Collections.Generic;
     using NUnit.Framework;
+    using NUnit.Framework.Interfaces;
 
     /// <summary>
     /// Verify the behavior of the Window operator
@@ -162,24 +178,5 @@ public void TestWindowWindowsImmutability()
                 reader.ReadEnd();
             }
         }
-
-        static IEnumerable<T> Seq<T>(params T[] values) => values;
-
-        public static readonly IEnumerable<ITestCaseData> TestData =
-            from e in new[]
-            {
-                new {Source = Enumerable.Range(0, 4), Size = 1, Result = new[] {Seq(0), Seq(1), Seq(2), Seq(3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 2, Result = new[] {Seq(0, 1), Seq(1, 2), Seq(2, 3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 3, Result = new[] {Seq(0, 1, 2), Seq(1, 2, 3)}},
-                new {Source = Enumerable.Range(0, 4), Size = 4, Result = new[] {Seq(0, 1, 2, 3)}}
-            }
-            select new TestCaseData(e.Source, e.Size).Returns(e.Result);
-
-        [Test, TestCaseSource(nameof(TestData))]
-        public IEnumerable<IEnumerable<int>> TestWindowOnKnownResults(IEnumerable<int> sequence, int sizes)
-        {
-            using var testingSequence = sequence.AsTestingSequence();
-            return testingSequence.Window(sizes).ToList();
-        }
     }
 }

From af52c17f426ec49427ee470bfec1857f464c872d Mon Sep 17 00:00:00 2001
From: Orace <pierre.lando@gmail.com>
Date: Tue, 19 Nov 2019 23:00:04 +0100
Subject: [PATCH 11/13] Removed unused using directives

Co-Authored-By: Atif Aziz <code@raboof.com>
---
 MoreLinq.Test/WindowLeftTest.cs  | 1 -
 MoreLinq.Test/WindowRightTest.cs | 1 -
 MoreLinq.Test/WindowTest.cs      | 2 --
 MoreLinq/Window.cs               | 2 +-
 4 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index 0103baca3..38bac0285 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -19,7 +19,6 @@ namespace MoreLinq.Test
 {
     using System.Collections.Generic;
     using NUnit.Framework;
-    using NUnit.Framework.Interfaces;
 
     [TestFixture]
     public class WindowLeftTest
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index c72285c09..725ba4e75 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -19,7 +19,6 @@ namespace MoreLinq.Test
 {
     using System.Collections.Generic;
     using NUnit.Framework;
-    using NUnit.Framework.Interfaces;
 
     [TestFixture]
     public class WindowRightTest
diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index e7fba00d6..61e56b77b 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -17,9 +17,7 @@
 
 namespace MoreLinq.Test
 {
-    using System.Collections.Generic;
     using NUnit.Framework;
-    using NUnit.Framework.Interfaces;
 
     /// <summary>
     /// Verify the behavior of the Window operator
diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs
index 018f25b16..a3c5375f6 100644
--- a/MoreLinq/Window.cs
+++ b/MoreLinq/Window.cs
@@ -52,7 +52,7 @@ public static IEnumerable<IList<TSource>> Window<TSource>(this IEnumerable<TSour
                 if (i < size)
                     yield break;
 
-                while(iter.MoveNext())
+                while (iter.MoveNext())
                 {
                     // generate the next window by shifting forward by one item
                     // and do that before exposing the data

From 63e9dce5983660693d0d09b4e88f2e7355619b06 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Wed, 20 Nov 2019 15:49:38 +0100
Subject: [PATCH 12/13] Clean-up test names

---
 MoreLinq.Test/WindowTest.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs
index 61e56b77b..2fc765be9 100644
--- a/MoreLinq.Test/WindowTest.cs
+++ b/MoreLinq.Test/WindowTest.cs
@@ -35,7 +35,7 @@ public void TestWindowIsLazy()
         }
 
         [Test]
-        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
+        public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.Window(2).GetEnumerator();
@@ -50,7 +50,7 @@ public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
+        public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.Window(2).GetEnumerator();
@@ -65,7 +65,7 @@ public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowDoNotAffectPrevWindow()
+        public void WindowModifiedDoesNotAffectPreviousWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.Window(2).GetEnumerator();

From f07e20c8f278ae042538fd6e306637beb22b9e88 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Wed, 20 Nov 2019 15:52:08 +0100
Subject: [PATCH 13/13] Clean-up test names (part 2)

---
 MoreLinq.Test/WindowLeftTest.cs  | 6 +++---
 MoreLinq.Test/WindowRightTest.cs | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
index 38bac0285..c63dc071c 100644
--- a/MoreLinq.Test/WindowLeftTest.cs
+++ b/MoreLinq.Test/WindowLeftTest.cs
@@ -30,7 +30,7 @@ public void WindowLeftIsLazy()
         }
 
         [Test]
-        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
+        public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowLeft(2).GetEnumerator();
@@ -45,7 +45,7 @@ public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
+        public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowLeft(2).GetEnumerator();
@@ -60,7 +60,7 @@ public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowDoNotAffectPrevWindow()
+        public void WindowModifiedDoesNotAffectPreviousWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowLeft(2).GetEnumerator();
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
index 725ba4e75..d5296e307 100644
--- a/MoreLinq.Test/WindowRightTest.cs
+++ b/MoreLinq.Test/WindowRightTest.cs
@@ -30,7 +30,7 @@ public void WindowRightIsLazy()
         }
 
         [Test]
-        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
+        public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowRight(2).GetEnumerator();
@@ -45,7 +45,7 @@ public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
+        public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowRight(2).GetEnumerator();
@@ -60,7 +60,7 @@ public void ModifyWindowAfterMoveNextDoNotAffectNextWindow()
         }
 
         [Test]
-        public void ModifyWindowDoNotAffectPrevWindow()
+        public void WindowModifiedDoesNotAffectPreviousWindow()
         {
             var sequence = Enumerable.Range(0, 3);
             using var e = sequence.WindowRight(2).GetEnumerator();