public static void GetEnumerator_AggregateException(Labeled <Operation> source, Labeled <Operation> operation)
{
IEnumerator <int> enumerator = operation.Item(DefaultStart, DefaultSize, source.Item).GetEnumerator();
// Spin until concat hits
// Union-Left needs to spin more than once rarely.
if (operation.ToString().StartsWith("Concat") || operation.ToString().StartsWith("Union-Left:ParallelEnumerable"))
{
AssertThrows.Wrapped <DeliberateTestException>(() => { while (enumerator.MoveNext())
{
;
}
});
}
else
{
AssertThrows.Wrapped <DeliberateTestException>(() => enumerator.MoveNext());
}
if (operation.ToString().StartsWith("OrderBy") || operation.ToString().StartsWith("ThenBy"))
{
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
}
else
{
Assert.False(enumerator.MoveNext());
}
}
public static void Average_Long_Overflow()
{
AssertThrows.Wrapped <OverflowException>(() => UnorderedSources.Default(2).Select(x => x == 0 ? 1 : long.MaxValue).Average());
AssertThrows.Wrapped <OverflowException>(() => UnorderedSources.Default(2).Select(x => x == 0 ? (long?)1 : long.MaxValue).Average());
AssertThrows.Wrapped <OverflowException>(() => UnorderedSources.Default(2).Average(x => x == 0 ? -1 : long.MinValue));
AssertThrows.Wrapped <OverflowException>(() => UnorderedSources.Default(2).Average(x => x == 0 ? (long?)-1 : long.MinValue));
}
public static void First_AggregateException(Labeled <Operation> source, Labeled <Operation> operation)
{
if (operation.ToString().Contains("Concat-Left"))
{
// The vast majority of the time, the operation returns a result instead of failing.
// Sufficient cores on a test machine may make the optimizer start enumerating the results.
int?result = null;
var exception = Record.Exception(() => { result = operation.Item(DefaultStart, DefaultSize, source.Item).First(); });
if (result.HasValue)
{
Assert.Null(exception);
Assert.InRange(result.Value, DefaultStart, DefaultStart + DefaultSize);
}
else
{
Assert.NotNull(exception);
var ae = Assert.IsType <AggregateException>(exception);
Assert.All(ae.InnerExceptions, e => Assert.IsType <DeliberateTestException>(e));
}
}
else
{
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).First());
}
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).First(x => false));
}
public static void Zip_AsOrdered_ThreadedDeadlock(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount, int degree)
{
_ = leftCount;
_ = rightCount;
ParallelQuery <int> query = left.Item.WithDegreeOfParallelism(degree).Zip <int, int, int>(right.Item, (a, b) => { throw new DeliberateTestException(); });
AssertThrows.Wrapped <DeliberateTestException>(() => query.ToArray());
}
public static void SequenceEqual_DisposeException(Labeled <ParallelQuery <int> > left, Labeled <ParallelQuery <int> > right, int count)
{
ParallelQuery <int> leftQuery = left.Item;
ParallelQuery <int> rightQuery = right.Item;
AssertThrows.Wrapped <TestDisposeException>(() => leftQuery.SequenceEqual(new DisposeExceptionEnumerable <int>(rightQuery).AsParallel()));
AssertThrows.Wrapped <TestDisposeException>(() => new DisposeExceptionEnumerable <int>(leftQuery).AsParallel().SequenceEqual(rightQuery));
}
public static void Aggregate_AggregateException(Labeled <Operation> source, Labeled <Operation> operation)
{
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate((x, y) => x));
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(0, (x, y) => x + y));
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(0, (x, y) => x + y, r => r));
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(0, (a, x) => a + x, (l, r) => l + r, r => r));
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(() => 0, (a, x) => a + x, (l, r) => l + r, r => r));
}
public static void Max_AggregateException_NotComparable()
{
ArgumentException e = AssertThrows.Wrapped <ArgumentException>(() => ParallelEnumerable.Repeat(new NotComparable(0), 2).Max());
Assert.Null(e.ParamName);
e = AssertThrows.Wrapped <ArgumentException>(() => ParallelEnumerable.Range(0, 2).Max(x => new NotComparable(x)));
Assert.Null(e.ParamName);
}
public static void WithCancellation_ODEIssue(Labeled <ParallelQuery <int> > labeled, int count)
{
//the failure was an ODE coming out due to an ephemeral disposed merged cancellation token source.
ParallelQuery <int> left = labeled.Item.AsUnordered().WithExecutionMode(ParallelExecutionMode.ForceParallelism);
ParallelQuery <int> right = Enumerable.Range(0, 1024).Select(x => x).AsParallel().AsUnordered();
AssertThrows.Wrapped <OperationCanceledException>(() => left.GroupJoin(right, x => { throw new OperationCanceledException(); }, y => y, (x, e) => x).ForAll(x => { }));
AssertThrows.Wrapped <OperationCanceledException>(() => left.Join(right, x => { throw new OperationCanceledException(); }, y => y, (x, e) => x).ForAll(x => { }));
AssertThrows.Wrapped <OperationCanceledException>(() => left.Zip <int, int, int>(right, (x, y) => { throw new OperationCanceledException(); }).ForAll(x => { }));
}
public static void Sum_Long_Overflow()
{
AssertThrows.Wrapped <OverflowException>(() => new[] { long.MaxValue, 1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { (long?)long.MaxValue, 1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { long.MinValue, -1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { (long?)long.MinValue, -1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? long.MaxValue : x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? long.MaxValue : (long?)x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? long.MinValue : -x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? long.MinValue : -(long?)x));
}
public static void Sum_Decimal_Overflow()
{
AssertThrows.Wrapped <OverflowException>(() => new[] { decimal.MaxValue, 1M }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { (decimal?)decimal.MaxValue, 1M }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { decimal.MinValue, -1M }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { (decimal?)decimal.MinValue, -1M }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? decimal.MaxValue : x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? decimal.MaxValue : (decimal?)x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? decimal.MinValue : -x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? decimal.MinValue : -(decimal?)x));
}
public static void Sum_Int_Overflow()
{
AssertThrows.Wrapped <OverflowException>(() => new[] { int.MaxValue, 1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { (int?)int.MaxValue, 1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { int.MinValue, -1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => new[] { (int?)int.MinValue, -1 }.AsParallel().Sum());
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? int.MaxValue : x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? int.MaxValue : (int?)x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? int.MinValue : -x));
AssertThrows.Wrapped <OverflowException>(() => ParallelEnumerable.Range(0, 2).Sum(x => x == 0 ? int.MinValue : -(int?)x));
}
public static void GetEnumerator_MoveNextAfterQueryOpeningFailsIsIllegal(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item.Select <int, int>(x => { throw new DeliberateTestException(); }).OrderBy(x => x);
IEnumerator <int> enumerator = query.GetEnumerator();
//moveNext will cause queryOpening to fail (no element generated)
AssertThrows.Wrapped <DeliberateTestException>(() => enumerator.MoveNext());
//moveNext after queryOpening failed
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
}
public static void ToLookup_AggregateException(Labeled <ParallelQuery <int> > labeled, int count)
{
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup((Func <int, int>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup((Func <int, int>)(x => { throw new DeliberateTestException(); }), y => y));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup(x => x, (Func <int, int>)(y => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup((Func <int, int>)(x => { throw new DeliberateTestException(); }), EqualityComparer <int> .Default));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup((Func <int, int>)(x => { throw new DeliberateTestException(); }), y => y, EqualityComparer <int> .Default));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup(x => x, (Func <int, int>)(y => { throw new DeliberateTestException(); }), EqualityComparer <int> .Default));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup(x => x, new FailingEqualityComparer <int>()));
AssertThrows.Wrapped <DeliberateTestException>(() => labeled.Item.ToLookup(x => x, y => y, new FailingEqualityComparer <int>()));
}
public static void First_AggregateException(Labeled <Operation> source, Labeled <Operation> operation)
{
// Concat seems able to return the first element when the left query does not fail ("first" query).
// This test might be flaky in the case that it decides to run the right query too...
if (operation.ToString().Contains("Concat-Left"))
{
Assert.InRange(operation.Item(DefaultStart, DefaultSize, source.Item).First(), DefaultStart, DefaultStart + DefaultSize);
}
else
{
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).First());
}
AssertThrows.Wrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).First(x => false));
}
public static void Sum_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, int>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, int?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, long>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, long?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, float>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, float?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, double>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, double?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, decimal>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 2).Sum((Func <int, decimal?>)(x => { throw new DeliberateTestException(); })));
}
public static void Aggregate_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate((i, j) => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate(0, (i, j) => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate(0, (i, j) => { throw new DeliberateTestException(); }, i => i));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate <int, int, int>(0, (i, j) => i, i => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate(0, (i, j) => { throw new DeliberateTestException(); }, (i, j) => i, i => i));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate <int, int, int>(0, (i, j) => i, (i, j) => i, i => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate <int, int, int>(() => { throw new DeliberateTestException(); }, (i, j) => i, (i, j) => i, i => i));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate(() => 0, (i, j) => { throw new DeliberateTestException(); }, (i, j) => i, i => i));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate <int, int, int>(() => 0, (i, j) => i, (i, j) => i, i => { throw new DeliberateTestException(); }));
if (Environment.ProcessorCount >= 2)
{
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate(0, (i, j) => i, (i, j) => { throw new DeliberateTestException(); }, i => i));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(2).Aggregate(() => 0, (i, j) => i, (i, j) => { throw new DeliberateTestException(); }, i => i));
}
}
public static void Average_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, int>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, int?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, long>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, long?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, float>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, float?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, double>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, double?>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, decimal>)(x => { throw new DeliberateTestException(); })));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Average((Func <int, decimal?>)(x => { throw new DeliberateTestException(); })));
}
public static void ToDictionary_ElementSelector_UniqueKeys_CustomComparator(int count)
{
if (count > 2)
{
AssertThrows.Wrapped <ArgumentException>(() => UnorderedSources.Default(count).ToDictionary(x => x, y => y, new ModularCongruenceComparer(2)));
}
else if (count == 1 || count == 2)
{
IntegerRangeSet seen = new IntegerRangeSet(0, count);
foreach (KeyValuePair <int, int> entry in UnorderedSources.Default(count).ToDictionary(x => x, y => y, new ModularCongruenceComparer(2)))
{
seen.Add(entry.Key);
Assert.Equal(entry.Key, entry.Value);
}
seen.AssertComplete();
}
else
{
Assert.Empty(UnorderedSources.Default(count).ToDictionary(x => x, y => y, new ModularCongruenceComparer(2)));
}
}
public static void Cast_Unordered_Assignable_InvalidCastException(int count)
{
AssertThrows.Wrapped <InvalidCastException>(() => UnorderedSources.Default(count).Select(x => (Int32)x).Cast <Castable>().ForAll(x => {; }));
AssertThrows.Wrapped <InvalidCastException>(() => UnorderedSources.Default(count).Select(x => (Int32)x).Cast <Castable>().ToList());
}
public static void Any_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Any(x => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).Select((Func <int, int>)(x => { throw new DeliberateTestException(); })).Any());
}
public static void All_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => UnorderedSources.Default(1).All(x => { throw new DeliberateTestException(); }));
}
public static void Cast_InvalidCastException(Labeled <ParallelQuery <int> > labeled, int count)
{
AssertThrows.Wrapped <InvalidCastException>(() => labeled.Item.Cast <double>().ForAll(x => {; }));
AssertThrows.Wrapped <InvalidCastException>(() => labeled.Item.Cast <double>().ToList());
}
public static void SequenceEqual_AggregateException(Labeled <ParallelQuery <int> > left, Labeled <ParallelQuery <int> > right, int count)
{
AssertThrows.Wrapped <DeliberateTestException>(() => left.Item.SequenceEqual(right.Item, new FailingEqualityComparer <int>()));
}
public static void CountLongCount_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 1).Count(x => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 1).LongCount(x => { throw new DeliberateTestException(); }));
}
public static void ForAll_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 1).ForAll(x => { throw new DeliberateTestException(); }));
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 1).Select((Func <int, int>)(x => { throw new DeliberateTestException(); })).ForAll(x => { }));
}
public static void ToDictionary_DuplicateKeys_ElementSelector()
{
AssertThrows.Wrapped <ArgumentException>(() => ParallelEnumerable.Repeat(0, 2).ToDictionary(x => x, y => y));
}
public static void Cast_Unordered_InvalidCastException(int count)
{
AssertThrows.Wrapped <InvalidCastException>(() => UnorderedSources.Default(count).Cast <double>().ForAll(x => {; }));
AssertThrows.Wrapped <InvalidCastException>(() => UnorderedSources.Default(count).Cast <double>().ToList());
}
public static void ToDictionary_DuplicateKeys_ElementSelector_CustomComparator()
{
AssertThrows.Wrapped <ArgumentException>(() => ParallelEnumerable.Repeat(0, 2).ToDictionary(x => x, y => y, new ModularCongruenceComparer(2)));
}
public static void Contains_AggregateException()
{
AssertThrows.Wrapped <DeliberateTestException>(() => ParallelEnumerable.Range(0, 1).Contains(1, new FailingEqualityComparer <int>()));
}
public static void Cast_Assignable_InvalidCastException(Labeled <ParallelQuery <int> > labeled, int count)
{
_ = count;
AssertThrows.Wrapped <InvalidCastException>(() => labeled.Item.Select(x => (Int32)x).Cast <Castable>().ForAll(x => {; }));
AssertThrows.Wrapped <InvalidCastException>(() => labeled.Item.Select(x => (Int32)x).Cast <Castable>().ToList());
}
