Fix Segment to not move past sequence end

This is a squashed merge of PR #691 that closes #687.

Author: Orace

MoreLinq.Test/SegmentTest.cs

@@ -17,6 +17,8 @@
 
 namespace MoreLinq.Test
 {
+    using System.Collections.Generic;
+    using NUnit.Framework.Interfaces;
     using NUnit.Framework;
 
     /// <summary>
@@ -146,5 +148,29 @@ public void VerifyCanSegmentByPrevious()
             Assert.AreEqual(sequence.Distinct().Count(), result.Count());
             Assert.IsTrue(result.All(s => s.Count() == repCount));
         }
+
+        static IEnumerable<T> Seq<T>(params T[] values) => values;
+
+        public static readonly IEnumerable<ITestCaseData> TestData =
+            from e in new[]
+            {
+                // input sequence is empty
+                new { Source = Seq<int>(),            Expected = Seq<IEnumerable<int>>()         },
+                // input sequence contains only new segment start
+                new { Source = Seq(0, 3, 6),          Expected = Seq(Seq(0), Seq(3), Seq(6))     },
+                // input sequence do not contains new segment start
+                new { Source = Seq(1, 2, 4, 5),       Expected = Seq(Seq(1, 2, 4, 5))            },
+                // input sequence start with a segment start
+                new { Source = Seq(0, 1, 2, 3, 4, 5), Expected = Seq(Seq(0, 1, 2), Seq(3, 4, 5)) },
+                // input sequence do not start with a segment start
+                new { Source = Seq(1, 2, 3, 4, 5),    Expected = Seq(Seq(1, 2), Seq(3, 4, 5))    }
+            }
+            select new TestCaseData(e.Source).Returns(e.Expected);
+
+        [Test, TestCaseSource(nameof(TestData))]
+        public IEnumerable<IEnumerable<int>> TestSegment(IEnumerable<int> source)
+        {
+            return source.AsTestingSequence().Segment(v => v % 3 == 0);
+        }
     }
 }

MoreLinq/Segment.cs

@@ -76,44 +76,40 @@ public static IEnumerable<IEnumerable<T>> Segment<T>(this IEnumerable<T> source,
 
             return _(); IEnumerable<IEnumerable<T>> _()
             {
-                var index = -1;
                 using var iter = source.GetEnumerator();
 
-                var segment = new List<T>();
-                var prevItem = default(T);
+                // early break
+                if (!iter.MoveNext())
+                    yield break;
 
                 // ensure that the first item is always part
                 // of the first segment. This is an intentional
                 // behavior. Segmentation always begins with
                 // the second element in the sequence.
-                if (iter.MoveNext())
-                {
-                    ++index;
-                    segment.Add(iter.Current);
-                    prevItem = iter.Current;
-                }
+                var prevItem = iter.Current;
+                var segment = new List<T> { iter.Current };
 
-                while (iter.MoveNext())
+                for (var index = 1; iter.MoveNext(); index++)
                 {
-                    ++index;
                     // check if the item represents the start of a new segment
-                    var isNewSegment = newSegmentPredicate(iter.Current, prevItem, index);
-                    prevItem = iter.Current;
+                    if (newSegmentPredicate(iter.Current, prevItem, index))
+                    {
+                        // yield the completed segment
+                        yield return segment;
 
-                    if (!isNewSegment)
+                        // start a new segment
+                        segment = new List<T> { iter.Current };
+                    }
+                    else
                     {
                         // if not a new segment, append and continue
                         segment.Add(iter.Current);
-                        continue;
                     }
-                    yield return segment; // yield the completed segment
 
-                    // start a new segment...
-                    segment = new List<T> { iter.Current };
+                    prevItem = iter.Current;
                 }
-                // handle the case of the sequence ending before new segment is detected
-                if (segment.Count > 0)
-                    yield return segment;
+
+                yield return segment;
             }
         }
     }