public void IteratorStateShouldNotChangeIfNumberOfElementsIsUnbounded() { // With https://github.com/dotnet/corefx/pull/13628, Skip and Take return // the same type of iterator. For Take, there is a limit, or upper bound, // on how many items can be returned from the iterator. An integer field, // _state, is incremented to keep track of this and to stop enumerating once // we pass that limit. However, for Skip, there is no such limit and the // iterator can contain an unlimited number of items (including past int.MaxValue). // This test makes sure that, in Skip, _state is not incorrectly incremented, // so that it does not overflow to a negative number and enumeration does not // stop prematurely. var iterator = new FastInfiniteEnumerator <int>().Skip(1).GetEnumerator(); iterator.MoveNext(); // Make sure the underlying enumerator has been initialized. FieldInfo state = iterator.GetType().GetTypeInfo() .GetField("_state", BindingFlags.Instance | BindingFlags.NonPublic); // On platforms that do not have this change, the optimization may not be present // and the iterator may not have a field named _state. In that case, nop. if (state != null) { state.SetValue(iterator, int.MaxValue); for (int i = 0; i < 10; i++) { Assert.True(iterator.MoveNext()); } } }
public void ChunkSourceLazily() { using IEnumerator <int[]> chunks = new FastInfiniteEnumerator <int>().Chunk(5).GetEnumerator(); chunks.MoveNext(); Assert.Equal(new[] { 0, 0, 0, 0, 0 }, chunks.Current); Assert.True(chunks.MoveNext()); }
public void ToArray_FailOnExtremelyLargeCollection() { var largeSeq = new FastInfiniteEnumerator <byte>(); var thrownException = Assert.ThrowsAny <Exception>(() => { largeSeq.ToArray(); }); Assert.True(thrownException.GetType() == typeof(OverflowException) || thrownException.GetType() == typeof(OutOfMemoryException)); }
public void IndexOverflow() { var selected = new FastInfiniteEnumerator<int>().SelectMany((e, i) => Enumerable.Empty<int>()); using (var en = selected.GetEnumerator()) Assert.Throws<OverflowException>(() => { while(en.MoveNext()) { } }); }
public void IndexTakeWhileOverflowBeyondIntMaxValueElements() { var taken = new FastInfiniteEnumerator <int>().TakeWhile((e, i) => true); using (var en = taken.GetEnumerator()) Assert.Throws <OverflowException>(() => { while (en.MoveNext()) { } }); }
public void IndexSkipWhileOverflowBeyondIntMaxValueElements() { var skipped = new FastInfiniteEnumerator().SkipWhile((e, i) => true); using (var en = skipped.GetEnumerator()) Assert.Throws <OverflowException>(() => { while (en.MoveNext()) { } }); }
public void IndexOverflows() { var infiniteWhere = new FastInfiniteEnumerator <int>().Where((e, i) => true); using (var en = infiniteWhere.GetEnumerator()) Assert.Throws <OverflowException>(() => { while (en.MoveNext()) { } }); }