fix .Concat() operation don't check length overflow #93

Author: neuecc

src/ZLinq/Linq/Concat.cs

@@ -56,7 +56,7 @@ public bool TryGetNonEnumeratedCount(out int count)
  {
  if (first.TryGetNonEnumeratedCount(out var count1) && second.TryGetNonEnumeratedCount(out var count2))
  {
- count = count1 + count2;
+ count = checked(count1 + count2);
  return true;
  }
  count = 0;

tests/ZLinq.Tests/Linq/ConcatTest.cs

@@ -254,4 +254,27 @@ public void Concat_MultipleOperations_ShouldWorkCorrectly()
  }
 
  #endregion
+
+ //[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsSpeedOptimized))]
+ [Fact]
+ public void CountOfConcatIteratorShouldThrowExceptionOnIntegerOverflow()
+ {
+ var supposedlyLargeCollection = new DelegateBasedCollection<int> { CountWorker = () => int.MaxValue };
+ var tinyCollection = new DelegateBasedCollection<int> { CountWorker = () => 1 };
+
+ // We need to use checked arithmetic summing up the collections' counts.
+ Assert.Throws<OverflowException>(() => supposedlyLargeCollection.AsValueEnumerable().Concat(tinyCollection).Count());
+ Assert.Throws<OverflowException>(() => tinyCollection.Concat(tinyCollection).Concat(supposedlyLargeCollection).Count());
+ Assert.Throws<OverflowException>(() => tinyCollection.Concat(tinyCollection).Concat(tinyCollection).Concat(supposedlyLargeCollection).Count());
+
+ //// This applies to ToArray() and ToList() as well, which try to preallocate the exact size
+ //// needed if all inputs are ICollections.
+ Assert.Throws<OverflowException>(() => supposedlyLargeCollection.Concat(tinyCollection).ToArray());
+ Assert.Throws<OverflowException>(() => tinyCollection.Concat(tinyCollection).Concat(supposedlyLargeCollection).ToArray());
+ Assert.Throws<OverflowException>(() => tinyCollection.Concat(tinyCollection).Concat(tinyCollection).Concat(supposedlyLargeCollection).ToArray());
+
+ Assert.Throws<OverflowException>(() => supposedlyLargeCollection.Concat(tinyCollection).ToList());
+ Assert.Throws<OverflowException>(() => tinyCollection.Concat(tinyCollection).Concat(supposedlyLargeCollection).ToList());
+ Assert.Throws<OverflowException>(() => tinyCollection.Concat(tinyCollection).Concat(tinyCollection).Concat(supposedlyLargeCollection).ToList());
+ }
 }

tests/ZLinq.Tests/TestUtil.cs

@@ -168,3 +168,39 @@ public void Dispose() { }
 
  public T Current => default(T)!;
 }
+
+public class DelegateBasedCollection<T> : ICollection<T>
+{
+ public Func<int> CountWorker { get; set; }
+ public Func<bool> IsReadOnlyWorker { get; set; }
+ public Action<T> AddWorker { get; set; }
+ public Action ClearWorker { get; set; }
+ public Func<T, bool> ContainsWorker { get; set; }
+ public Func<T, bool> RemoveWorker { get; set; }
+ public Action<T[], int> CopyToWorker { get; set; }
+ public Func<IEnumerator<T>> GetEnumeratorWorker { get; set; }
+ public Func<IEnumerator> NonGenericGetEnumeratorWorker { get; set; }
+
+ public DelegateBasedCollection()
+ {
+ CountWorker = () => 0;
+ IsReadOnlyWorker = () => false;
+ AddWorker = item => { };
+ ClearWorker = () => { };
+ ContainsWorker = item => false;
+ RemoveWorker = item => false;
+ CopyToWorker = (array, arrayIndex) => { };
+ GetEnumeratorWorker = () => Enumerable.Empty<T>().GetEnumerator();
+ NonGenericGetEnumeratorWorker = () => GetEnumeratorWorker();
+ }
+
+ public int Count => CountWorker();
+ public bool IsReadOnly => IsReadOnlyWorker();
+ public void Add(T item) => AddWorker(item);
+ public void Clear() => ClearWorker();
+ public bool Contains(T item) => ContainsWorker(item);
+ public bool Remove(T item) => RemoveWorker(item);
+ public void CopyTo(T[] array, int arrayIndex) => CopyToWorker(array, arrayIndex);
+ public IEnumerator<T> GetEnumerator() => GetEnumeratorWorker();
+ IEnumerator IEnumerable.GetEnumerator() => NonGenericGetEnumeratorWorker();
+}