Refactor Window(Left|Right)

MoreLinq.Test/WindowLeftTest.cs

@@ -1,7 +1,25 @@
+#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
@@ -12,6 +30,51 @@ public void WindowLeftIsLazy()
             new BreakingSequence<int>().WindowLeft(1);
         }
 
+        [Test]
+        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
+        {
+            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 ModifyWindowDoNotAffectPrevWindow()
+        {
+            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]
         public void WindowLeftWithNegativeWindowSize()
         {
@@ -76,5 +139,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;
+        }
     }
 }

MoreLinq.Test/WindowRightTest.cs

@@ -1,7 +1,25 @@
+#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
@@ -12,6 +30,51 @@ public void WindowRightIsLazy()
             new BreakingSequence<int>().WindowRight(1);
         }
 
+        [Test]
+        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
+        {
+            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 ModifyWindowDoNotAffectPrevWindow()
+        {
+            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]
         public void WindowRightWithNegativeWindowSize()
         {
@@ -76,5 +139,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;
+        }
     }
 }

MoreLinq.Test/WindowTest.cs

@@ -1,6 +1,25 @@
+#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
@@ -17,6 +36,51 @@ public void TestWindowIsLazy()
             new BreakingSequence<int>().Window(1);
         }
 
+        [Test]
+        public void ModifyWindowBeforeMoveNextDoNotAffectNextWindow()
+        {
+            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 ModifyWindowDoNotAffectPrevWindow()
+        {
+            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>
         /// Verify that a negative window size results in an exception
         /// </summary>
@@ -25,7 +89,7 @@ public void TestWindowNegativeWindowSizeException()
         {
             var sequence = Enumerable.Repeat(1, 10);
 
-            AssertThrowsArgument.OutOfRangeException("size",() =>
+            AssertThrowsArgument.OutOfRangeException("size", () =>
                 sequence.Window(-5));
         }
 
@@ -114,5 +178,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();
+        }
     }
 }