public void ExecutionIsDeferred() { IEnumerableWithCount<int> throwingEnumerable = new ThrowingEnumerable(15); Assert.AreEqual(15, throwingEnumerable.Count); IEnumerableWithCount<int> result = throwingEnumerable.Take(10); Assert.AreEqual(10, result.Count); }
public void ExecutionIsDeferred() { var outer = new ThrowingEnumerable(); var inner = new ThrowingEnumerable(); outer.Join(inner, x => x, y => y, (x, y) => x + y); }
public void ExecutionIsDeferred() { var outer = new ThrowingEnumerable(); var inner = new ThrowingEnumerable(); // No exception outer.Join(inner, x => x, y => y, (x, y) => x + y); }
public void ExecutionIsDeferred() { var first = new ThrowingEnumerable(); var second = new ThrowingEnumerable(); first.Zip(second, (x, y) => x + y); }
public void ExecutionIsDeferred() { IEnumerable source = new ThrowingEnumerable(); // No exception source.OfType <string>(); }
public void ExecutionIsDeferredAndCountWorks() { IEnumerableWithCount<int> first = new ThrowingEnumerable(5); IEnumerableWithCount<int> second = new ThrowingEnumerable(7); IEnumerableWithCount<int> result = first.Zip(second, (x, y) => x + y); Assert.AreEqual(5, result.Count); }
public void DoesNotIterateForCount() { IEnumerableWithCount<int> throwingEnumerable = new ThrowingEnumerable(5); IOrderedEnumerableWithCount<int> orderBy = throwingEnumerable.OrderBy(x => x); IOrderedEnumerableWithCount<int> result = orderBy.ThenBy(x => x); Assert.AreEqual(5, result.Count); }
public void DoesNotRequireEnumerationOfEitherInput() { IEnumerableWithCount<int> first = new ThrowingEnumerable(7); IEnumerableWithCount<int> second = new ThrowingEnumerable(10); IEnumerableWithCount<int> result = first.Concat(second); Assert.AreEqual(17, result.Count); }
public void CountOptimization() { // The counts are different, so we don't need to iterate var first = new ThrowingEnumerable(5); var second = new ThrowingEnumerable(10); Assert.IsFalse(first.SequenceEqual(second)); }
public void ExecutionIsDeferred() { var first = new ThrowingEnumerable(); var second = new ThrowingEnumerable(); new AdjustedZipEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, int, AddOperator>(first, second); }
public void CountDoesNotEnumerate() { IEnumerableWithCount source = new ThrowingEnumerable(7); // No exception IEnumerableWithCount<string> result = source.Cast<string>(); Assert.AreEqual(7, result.Count); }
public static void Append1() { IEnumerable <int> source = new ThrowingEnumerable <int>(); var q = Assert.DoesNotThrow(() => source.Append(1)); Assert.ThrowsOnNext(q); }
public static void CollectAny1a() { IEnumerable <Either <int, int> > source = new ThrowingEnumerable <Either <int, int> >(); var q = Assert.DoesNotThrow(() => source.CollectAny()); Assert.ThrowsOnNext(q); }
public static void CollectImpl1a() { IEnumerable <Either <int, int> > source = new ThrowingEnumerable <Either <int, int> >(); var q = Assert.DoesNotThrow(() => source.CollectImpl()); q.OnLeft(x => Assert.ThrowsOnNext(x)); q.OnRight(x => Assert.Fail()); }
public void FirstSequenceIsNotUsedUntilQueryIsIterated() { var query = new ThrowingEnumerable().Union(new[] { 1, 2 }); using (var enumerator = query.GetEnumerator()) // No exception expected here { Assert.Throws(typeof(InvalidOperationException), () => enumerator.MoveNext()); } }
public void FirstSequenceIsNotAccessedBeforeFirstUse() { var first = new ThrowingEnumerable(); var query = first.Concat(new[] { 1, 2, 3 }); using (var iterator = query.GetEnumerator()) { Assert.Throws(typeof(InvalidOperationException), () => iterator.MoveNext()); } }
public void NoSequencesUsedBeforeIteration() { var first = new ThrowingEnumerable(); var second = new ThrowingEnumerable(); var query = first.Union(second); using (query.GetEnumerator()) { } }
public static void Prepend1() { IEnumerable <int> source = new ThrowingEnumerable <int>(); var q = Assert.DoesNotThrow(() => source.Prepend(1)); // We bypass the first iteration (we just prepended 1 to the sequence, // iterating won't throw immediately). Assert.ThrowsAfter(q, 1); }
public static void Zip1a() { IEnumerable <int> first = new ThrowingEnumerable <int>(); var second = Enumerable.Range(0, 1); Func <int, int, Either <int, int> > resultSelector = (i, j) => Either <int, int> .OfLeft(i + j); var q = Assert.DoesNotThrow(() => Either.Zip(first, second, resultSelector)); q.OnLeft(x => Assert.ThrowsOnNext(x)); q.OnRight(x => Assert.Fail()); }
public void FirstSequenceIsNotUsedUntilQueryIsIterated() { var first = new ThrowingEnumerable(); int[] second = { 2 }; var query = first.Union(second); using (var iterator = query.GetEnumerator()) { // Still no exception... until we call MoveNext Assert.Throws<InvalidOperationException>(() => iterator.MoveNext()); } }
public void NoSequencesUsedBeforeIteration() { var first = new ThrowingEnumerable(); var second = new ThrowingEnumerable(); // No exceptions! var query = first.Union(second); // Still no exceptions... we're not calling MoveNext. using (var iterator = query.GetEnumerator()) { } }
public void SecondSequenceIsNotAccessedBeforeFirstUse() { var second = new ThrowingEnumerable(); var query = new[] { 1, 2 }.Concat(second); using (var iterator = query.GetEnumerator()) { Assert.IsTrue(iterator.MoveNext()); Assert.IsTrue(iterator.MoveNext()); Assert.Throws(typeof(InvalidOperationException), () => iterator.MoveNext()); } }
public void FirstSequenceIsntAccessedBeforeFirstUse() { IEnumerableWithCount<int> first = new ThrowingEnumerable(0); IEnumerableWithCount<int> second = new int[] { 5 }.AsEnumerableWithCount(); // No exception yet... var query = first.Concat(second); // Still no exception... using (var iterator = query.GetEnumerator()) { // Now it will go bang Assert.Throws<InvalidOperationException>(() => iterator.MoveNext()); } }
public void FirstSequenceIsNotUsedUntilQueryIsIterated() { var first = new ThrowingEnumerable(); int[] second = { 2 }; var query = first.Union(second); using (var iterator = query.GetEnumerator()) { // Still no exception... until we call MoveNext Assert.Throws <InvalidOperationException>(() => iterator.MoveNext()); } }
public void FirstSequenceIsntAccessedBeforeFirstUse() { IEnumerable <int> first = new ThrowingEnumerable(); IEnumerable <int> second = new int[] { 5 }; // No exception yet... var query = first.Concat(second); // Still no exception... using (var iterator = query.GetEnumerator()) { // Now it will go bang Assert.Throws <InvalidOperationException>(() => iterator.MoveNext()); } }
public void FirstSequenceIsntAccessedBeforeFirstUse() { var first = new ThrowingEnumerable(); int[] second = { 5 }; // No exception yet... var query = new ConcatEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, ArrayEnumerable <int>, ArrayEnumerable <int> .Enumerator, int>(first, second.AsRefEnumerable()); // Still no exception... using (var iterator = query.GetEnumerator()) { // Now it will go bang Assert.Throws <InvalidOperationException>(() => iterator.MoveNext()); } }
public void SecondSequenceIsntAccessedBeforeFirstUse() { IEnumerableWithCount<int> first = new int[] { 5 }.AsEnumerableWithCount(); IEnumerableWithCount<int> second = new ThrowingEnumerable(0); // No exception yet... var query = first.Concat(second); // Still no exception... using (var iterator = query.GetEnumerator()) { // First element is fine... Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(5, iterator.Current); // Now it will go bang, as we move into the second sequence Assert.Throws<InvalidOperationException>(() => iterator.MoveNext()); } }
public void SecondSequenceIsNotUsedUntilFirstIsExhausted() { int[] first = { 3, 5, 3 }; var second = new ThrowingEnumerable(); using (var iterator = first.Union(second).GetEnumerator()) { // Check the first two elements... Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(3, iterator.Current); Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(5, iterator.Current); // But as soon as we move past the first sequence, bang! Assert.Throws<InvalidOperationException>(() => iterator.MoveNext()); } }
public void SecondSequenceIsNotUsedUntilFirstIsExhausted() { int[] first = { 3, 5, 3 }; var second = new ThrowingEnumerable(); using (var iterator = first.Union(second).GetEnumerator()) { // Check the first two elements... Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(3, iterator.Current); Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(5, iterator.Current); // But as soon as we move past the first sequence, bang! Assert.Throws <InvalidOperationException>(() => iterator.MoveNext()); } }
public void SecondSequenceIsntAccessedBeforeFirstUse() { IEnumerable <int> first = new int[] { 5 }; IEnumerable <int> second = new ThrowingEnumerable(); // No exception yet... var query = first.Concat(second); // Still no exception... using (var iterator = query.GetEnumerator()) { // First element is fine... Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(5, iterator.Current); // Now it will go bang, as we move into the second sequence Assert.Throws <InvalidOperationException>(() => iterator.MoveNext()); } }
public void DoesNotCallGetEnumerator() { var source = new ThrowingEnumerable(); Assert.AreSame(source, source.AsEnumerable()); }
public void WithIndexExecutionIsDeferred() { ThrowingEnumerable.AssertDeferred(src => src.Select((x, index) => x + index)); }
public void ExecutionIsDeferred() { ThrowingEnumerable.AssertDeferred(src => src.Select(x => x * 2)); }
public void DoesNotIterateWhenEmpty() { IEnumerableWithCount<int> source = new ThrowingEnumerable(0); Assert.AreEqual(0, source.LastOrDefault()); }
public void MultipleElementSequenceDoesNotIterate() { IEnumerableWithCount<int> source = new ThrowingEnumerable(2); Assert.Throws<InvalidOperationException>(() => source.SingleOrDefault()); }
public void ExecutionIsDeferred() { IEnumerableWithCount<int> throwingEnumerable = new ThrowingEnumerable(0); IOrderedEnumerableWithCount<int> orderBy = throwingEnumerable.OrderBy(x => x); IOrderedEnumerableWithCount<int> result = orderBy.ThenBy(x => x); }
public void WithIndexExecutionIsDeferred() { ThrowingEnumerable.AssertDeferred(src => new WhereIndexEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, PredicateGreaterThan>(new ThrowingEnumerable(), new PredicateGreaterThan(0))); }
public void DoesNotIterateForCount() { IEnumerableWithCount<int> source = new ThrowingEnumerable(3); IEnumerableWithCount<int> result = source.OrderByDescending(x => x); Assert.AreEqual(3, result.Count); }
public void DoesNotCallGetEnumerator() { IEnumerableWithCount<int> source = new ThrowingEnumerable(0); Assert.AreSame(source, source.AsEnumerable()); }
public void DoesNotIterateOnOvershootIndex() { IEnumerableWithCount<int> source = new ThrowingEnumerable(7); Assert.AreEqual(0, source.ElementAtOrDefault(7)); }
public void ExecutionIsDeferred() { var outer = new ThrowingEnumerable(); var inner = new ThrowingEnumerable(); // No exception var join = new JoinEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, int, AsIs <int>, AsIs <int>, DefaultEqualityComparer <int>, int, AddInt>(outer, inner, default, default, default, default, Allocator.Temp);
public void DoesNotIterate() { IEnumerableWithCount<int> source = new ThrowingEnumerable(5); Assert.AreEqual(5, source.Count); }
public void NoSequencesUsedBeforeIteration() { var first = new ThrowingEnumerable(); var second = new ThrowingEnumerable(); // No exceptions! var query = new SetOperationEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, IntersectOperation <ThrowingEnumerable, ThrowingEnumerable.Enumerator, ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, DefaultEqualityComparer <int> > >(first, second, default, Allocator.Persistent);
public void ExecutionIsDeferred() { IEnumerableWithCount<int> throwingEnumerable = new ThrowingEnumerable(0); throwingEnumerable.Reverse(); }
public void DoesNotEnumerateWhenNotEmpty() { IEnumerableWithCount<int> source = new ThrowingEnumerable(7); // No exception Assert.IsTrue(source.Any()); }
public void ExecutionIsDeferred() { ThrowingEnumerable.AssertDeferred(src => src.Where((x, i) => x > 0)); }
public void SourceSequenceIsReadEagerly() { var source = new ThrowingEnumerable(); Assert.Throws <InvalidOperationException>(() => source.ToLookup(x => x)); }
public void ExecutionIsDeferred() { IEnumerable source = new ThrowingEnumerable(); // No exception source.OfType<string>(); }
public void ExecutionIsDeferred() { ThrowingEnumerable.AssertDeferred(src => new SelectEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, int, DelegateFuncToStructOperatorAction <int, int> >(src, new DelegateFuncToStructOperatorAction <int, int>(x => x * 2))); }
public void ExecutionIsDeferred() { IEnumerableWithCount<int> throwingEnumerable = new ThrowingEnumerable(0); throwingEnumerable.OrderByDescending(x => x); }
public void EmptySequenceDoesNotIterate() { IEnumerableWithCount<int> source = new ThrowingEnumerable(0); Assert.AreEqual(0, source.SingleOrDefault()); }
public void DoesNotIterateWhenEmpty() { IEnumerableWithCount<int> source = new ThrowingEnumerable(0); Assert.Throws<InvalidOperationException>(() => source.Last()); }
public void SourceSequenceIsReadEagerly() { var source = new ThrowingEnumerable(); Assert.Throws<InvalidOperationException>(() => source.ToLookup(x => x)); }
public void DoesNotIterateForCount() { IEnumerableWithCount<int> source = new ThrowingEnumerable(10); IEnumerableWithCount<int> result = source.Select(x => x * 2); Assert.AreEqual(10, result.Count); }
public void ExecutionIsDeferred() { var outer = new ThrowingEnumerable(); var inner = new ThrowingEnumerable(); outer.GroupJoin(inner, x => x, y => y, (x, y) => x + y.Count()); }
public void WithIndexExecutionIsDeferred() { ThrowingEnumerable.AssertDeferred(src => new SelectIndexEnumerable <ThrowingEnumerable, ThrowingEnumerable.Enumerator, int, long, DelegateFuncToSelectIndexStructOperator <int, long> >(src, new DelegateFuncToSelectIndexStructOperator <int, long>((x, index) => x + index))); }