public static void Except_Distinct(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int start, int count)
{
ParallelQuery<int> leftQuery = left.Item;
leftCount = Math.Min(DuplicateFactor * 2, leftCount);
rightCount = Math.Min(DuplicateFactor, (rightCount + 1) / 2);
int expectedCount = Math.Max(0, leftCount - rightCount);
int seen = expectedCount == 0 ? 0 : leftCount - expectedCount;
foreach (int i in leftQuery.Except(rightQuery.Select(x => Math.Abs(x) % DuplicateFactor), new ModularCongruenceComparer(DuplicateFactor * 2)))
{
Assert.Equal(seen++, i);
}
Assert.Equal(expectedCount == 0 ? 0 : leftCount, seen);
}
/// <summary>
/// Filters the sequence of IVerbal constructs selecting those with at least one bound
/// indirect object.
/// </summary>
/// <param name="verbals">The Enumerable of Verb objects to filter.</param>
/// <typeparam name="TVerbal">Any Type which implements the IVerbal interface.</typeparam>
/// <returns>The subset of IVerbal constructs bound to an indirect object.</returns>
public static ParallelQuery <TVerbal> WithIndirectObject <TVerbal>(this ParallelQuery <TVerbal> verbals)
where TVerbal : IVerbal => from verbal in verbals
where verbal.HasIndirectObject()
select verbal;
/// <summary>
/// Filters a collection of IVerbal constructs returning those who have at least one bound
/// direct OR indirect object matching the provided object testing function.
/// </summary>
/// <typeparam name="TVerbal">Any Type which implements the IVerbal interface.</typeparam>
/// <param name="verbals">The Enumerable of IVerbal constructs to filter.</param>
/// <param name="condition">
/// The function specifying the match verbalSelector. Any function which takes an IEntity
/// and returns a bool is compatible.
/// </param>
/// <returns>
/// The subset of IVerbal constructs bound to at least one bound direct OR indirect object
/// which matches the condition.
/// </returns>
public static ParallelQuery <TVerbal> WithObject <TVerbal>(this ParallelQuery <TVerbal> verbals, Func <IEntity, bool> condition)
where TVerbal : IVerbal => verbals.WithObject().Where(verbal => verbal.HasObject(condition));
public static void Union_SecondOrdered_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
IntegerRangeSet seenUnordered = new IntegerRangeSet(0, leftCount);
int seen = leftCount;
foreach (int i in leftQuery.Union(rightQuery.AsOrdered()))
{
if (i >= leftCount)
{
Assert.Equal(seen++, i);
}
else
{
seenUnordered.Add(i);
}
}
Assert.Equal(count, seen);
seenUnordered.AssertComplete();
}
public static ParallelQuery <XElement> ChangeXNames([NotNull][ItemNotNull] this ParallelQuery <XElement> elements, [NotNull] Func <XElement, bool> predicate, [NotNull] XName name) => elements.Select(x => x.ChangeXNames(predicate, name));
public static void Intersect_Distinct_NotPipelined_Longrunning(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
Intersect_Distinct_NotPipelined(left, leftCount, rightQuery, rightCount, count);
}
public static void Distinct_SourceMultiple_Longrunning(ParallelQuery<int> query, int count)
{
Distinct_SourceMultiple(query, count);
}
public static void Except_Unordered_SourceMultiple_Longrunning(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int start, int count)
{
Except_Unordered_SourceMultiple(leftQuery, leftCount, rightQuery, rightCount, start, count);
}
public static void Except_SourceMultiple(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int start, int count)
{
int seen = start;
Assert.All(leftQuery.Except(rightQuery), x => Assert.Equal(seen++, x));
Assert.Equal(start + count, seen);
}
public static void ElementAtOrDefault_OutOfRange(Labeled <ParallelQuery <int> > labeled, int count, int position)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(default(int), query.ElementAtOrDefault(position));
}
public static void ElementAt_OutOfRange(Labeled <ParallelQuery <int> > labeled, int count, int position)
{
ParallelQuery <int> query = labeled.Item;
Assert.Throws <ArgumentOutOfRangeException>(() => query.ElementAt(position));
}
public static void Range_LastOrDefault(int start, int count)
{
ParallelQuery <int> query = ParallelEnumerable.Range(start, count);
Assert.Equal(count == 0 ? 0 : start + (count - 1), query.LastOrDefault());
}
/// <summary>
/// Schedules execution of the merge itself.
/// </summary>
public void Execute()
{
ParallelQuery<int> query = ParallelEnumerable.Range(0, m_queryResults.Count);
query = new QueryExecutionOption<int>(QueryOperator<int>.AsQueryOperator(query), m_settings);
query.ForAll(ToArrayElement);
}
public static ParallelQuery <XElement> ChangeXNames([NotNull][ItemNotNull] this ParallelQuery <XElement> elements, [NotNull] XName oldName, [NotNull] XName newName) => elements.Select(x => x.ChangeXNames(oldName, newName));
public static void Intersect_Longrunning(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> right, int rightCount, int count)
{
Intersect(left, leftCount, right, rightCount, count);
}
/// <summary>
/// Returns all Entities in the given sequence which are bound to an IDescriptor.
/// </summary>
/// <typeparam name="TEntity">Any Type which implements the IDescribable interface.</typeparam>
/// <param name="entities">The sequence of IDescribables to filter.</param>
/// <returns>All Entities in the given sequence which are bound to an IDescriptor.</returns>
public static ParallelQuery <TEntity> HavingDescriptor <TEntity>(this ParallelQuery <TEntity> entities)
where TEntity : IEntity => from e in entities
where e.Descriptors.Any()
select e;
public static void Intersect_Distinct(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
ParallelQuery<int> leftQuery = left.Item;
leftCount = Math.Min(DuplicateFactor * 2, leftCount);
rightCount = Math.Min(DuplicateFactor, (rightCount + 1) / 2);
int seen = 0;
foreach (int i in leftQuery.Intersect(rightQuery.Select(x => Math.Abs(x) % DuplicateFactor), new ModularCongruenceComparer(DuplicateFactor * 2)))
{
Assert.Equal(seen++, i);
}
Assert.Equal(Math.Min(leftCount, rightCount), seen);
}
/// <summary>
/// Returns all IDescribable Constructs in the given sequence which are bound to an
/// IDescriptor that matches the given descriptorMatcher predicate function.
/// </summary>
/// <typeparam name="TEntity">Any Type which implements the IDescribable interface.</typeparam>
/// <param name="entities">The sequence of IDescribables to filter.</param>
/// <param name="predicate">
/// The function which examines the descriptors bound to each element in the sequence.
/// </param>
/// <returns>
/// All IDescribable Constructs in the given sequence which are bound to an IDescriptor that
/// matches the given descriptorMatcher predicate function.
/// </returns>
public static ParallelQuery <TEntity> HavingDescriptor <TEntity>(this ParallelQuery <TEntity> entities, Func <IDescriptor, bool> predicate)
where TEntity : IEntity => from e in entities
where e.Descriptors.Any(predicate)
select e;
private static void DisposedEnumerator(ParallelQuery<int> query, bool delay = false)
{
query = query.WithCancellation(new CancellationTokenSource().Token).Select(x => x);
IEnumerator<int> enumerator = query.GetEnumerator();
enumerator.MoveNext();
if (delay) Task.Delay(10).Wait();
enumerator.MoveNext();
enumerator.Dispose();
Assert.Throws<ObjectDisposedException>(() => enumerator.MoveNext());
}
/// <summary>
/// Returns all IEntity constructs in the source sequence which have been bound as the
/// Indirect Object of an IVerbal construct.
/// </summary>
/// <typeparam name="TEntity">Any Type which implements the IEntity interface.</typeparam>
/// <param name="entities">The sequence of IEntity constructs to filter.</param>
/// <returns>
/// All IEntity constructs in the source sequence which have been bound as the Indirect
/// Object of an IVerbal construct.
/// </returns>
public static ParallelQuery <TEntity> InIndirectObjectRole <TEntity>(this ParallelQuery <TEntity> entities)
where TEntity : IEntity => from e in entities
where e.IndirectObjectOf != null
select e;
public static void Except_Unordered_SourceMultiple_Longrunning(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int start, int count)
{
Except_Unordered_SourceMultiple(leftQuery, leftCount, rightQuery, rightCount, start, count);
}
/// <summary>
/// Returns all IEntity constructs in the source sequence which have been bound as the
/// Indirect Object of any IVerbal construct which conforms the logic of the IVerbal
/// selector function.
/// </summary>
/// <typeparam name="TEntity">Any Type which implements the IEntity interface.</typeparam>
/// <param name="entities">The sequence of IEntity constructs to filter.</param>
/// <param name="predicate">
/// The function which examines the IndirectObjectOf property of each entity to determine if
/// it should be included in the resulting sequence.
/// </param>
/// <returns>
/// All IEntity constructs in the source sequence which have been bound as the Indirect
/// Object of any IVerbal construct which conforms the logic of the IVerbal selector function.
/// </returns>
public static ParallelQuery <TEntity> InIndirectObjectRole <TEntity>(this ParallelQuery <TEntity> entities, Func <IVerbal, bool> predicate)
where TEntity : IEntity => from e in entities.InIndirectObjectRole()
where predicate(e.IndirectObjectOf)
select e;
public static void Union_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
int seen = 0;
Assert.All(leftQuery.AsOrdered().Union(rightQuery.AsOrdered()), x => Assert.Equal(seen++, x));
Assert.Equal(count, seen);
}
/// <summary>
/// Returns all IEntity constructs in the source sequence which have been bound as the
/// Subject, Direct Object, or Indirect Object of any IVerbal construct which conforms the
/// logic of the IVerbal selector function.
/// </summary>
/// <typeparam name="TEntity">Any Type which implements the IEntity interface.</typeparam>
/// <param name="entities">The sequence of IEntity constructs to filter.</param>
/// <param name="predicate">
/// The function which examines the IVerbal bound to each entity to determine if it should
/// be included in the resulting sequence.
/// </param>
/// <returns>
/// All IEntity constructs in the source sequence which have been bound as the Subject,
/// Direct Object, or Indirect Object of any IVerbal construct which conforms the logic of
/// the IVerbal selector function.
/// </returns>
public static ParallelQuery <TEntity> InSubjectOrObjectRole <TEntity>(this ParallelQuery <TEntity> entities, Func <IVerbal, bool> predicate)
where TEntity : IEntity => from e in entities
where e.SubjectOf != null && predicate(e.SubjectOf) ||
e.DirectObjectOf.Match(predicate) ||
e.IndirectObjectOf != null && predicate(e.IndirectObjectOf)
select e;
public static void GroupJoin_CustomComparator_LeftWithOrderingColisions(Labeled <ParallelQuery <int> > left, int leftCount, Labeled <ParallelQuery <int> > right, int rightCount)
{
ParallelQuery <int> leftQuery = left.Item.AsUnordered().OrderBy(x => x / KeyFactor);
ParallelQuery <int> rightQuery = right.Item;
int seenNonEmpty = 0;
int seenEmpty = 0;
int seenLeftGroup = 0;
int seenLeftCount = 0;
Assert.All(leftQuery.GroupJoin(rightQuery, x => x, y => y % ElementFactor, (x, y) => KeyValuePair.Create(x, y), new ModularCongruenceComparer(KeyFactor)),
p =>
{
seenLeftCount++;
if (p.Key / KeyFactor > seenLeftGroup)
{
seenLeftGroup++;
try
{
Assert.Equal(KeyFactor, seenEmpty + seenNonEmpty);
}
finally
{
seenEmpty = 0;
seenNonEmpty = 0;
}
}
Assert.Equal(seenLeftGroup, p.Key / KeyFactor);
if (p.Key % KeyFactor < Math.Min(ElementFactor, rightCount))
{
try
{
Assert.Equal((seenLeftGroup * KeyFactor) + seenNonEmpty, p.Key);
}
finally
{
seenNonEmpty++;
}
int expectedInner = p.Key % ElementFactor;
int seenInnerCount = 0;
Assert.All(p.Value, y =>
{
seenInnerCount++;
Assert.Equal(p.Key % KeyFactor, y % ElementFactor);
try
{
Assert.Equal(expectedInner, y);
}
finally
{
expectedInner += ElementFactor;
}
});
Assert.Equal((rightCount / ElementFactor) + (((rightCount % ElementFactor) > (p.Key % KeyFactor)) ? 1 : 0), seenInnerCount);
}
else
{
seenEmpty++;
Assert.Equal(0, seenNonEmpty);
Assert.Empty(p.Value);
}
});
Assert.Equal(leftCount, seenLeftCount);
}
/// <summary> /// Returns all IEntity constructs in the source sequence which have been bound as the /// Subject of an IVerbal construct. /// </summary> /// <typeparam name="TEntity">Any Type which implements the IEntity interface.</typeparam> /// <param name="entities">The sequence of Noun instances to filter.</param> /// <returns> /// All IEntity constructs in the source sequence which have been bound as the Subject of an /// IVerbal construct. /// </returns> public static ParallelQuery <TEntity> InSubjectRole <TEntity>(this ParallelQuery <TEntity> entities) where TEntity : IEntity => entities.Where(entity => entity.SubjectOf != null);
/// <summary>
/// Filters a collection of IVerbal constructs returning those who have at least one
/// indirect object which matches the provided object testing function
/// </summary>
/// <typeparam name="TVerbal">Any Type which implements the IVerbal interface.</typeparam>
/// <param name="verbals">The Enumerable of IVerbal constructs instances to filter.</param>
/// <param name="condition">
/// The function specifying the criteria an entity bound to the Verbal must match for it to
/// be included. Any function which takes an IEntity and return a bool is compatible.
/// </param>
/// <returns>
/// The subset of IVerbal constructs bound to at least one indirect object which matches the verbalSelector.
/// </returns>
public static ParallelQuery <TVerbal> WithIndirectObject <TVerbal>(this ParallelQuery <TVerbal> verbals, Func <IEntity, bool> condition)
where TVerbal : IVerbal => from verbal in verbals.WithIndirectObject()
where verbal.HasIndirectObject(condition)
select verbal;
/// <summary>
/// Returns all describables in the source sequence which have been bound as the Subject of
/// any IVerbal construct which conforms the logic of the IVerbal selector function.
/// </summary>
/// <typeparam name="TEntity">Any Type which implements the IEntity interface.</typeparam>
/// <param name="entities">The sequence of IEntity constructs to filter.</param>
/// <param name="predicate">
/// The function which examines the SubjectOf property of each entity to determine if it
/// should be included in the resulting sequence.
/// </param>
/// <returns>
/// All IEntity constructs in the source sequence which have been bound as the Subject of
/// any IVerbal construct which conforms the logic of the IVerbal selector function.
/// </returns>
public static ParallelQuery <TEntity> InSubjectRole <TEntity>(this ParallelQuery <TEntity> entities, Func <IVerbal, bool> predicate)
where TEntity : IEntity => from entity in entities
let verbal = entity.SubjectOf
where verbal != null
where predicate(entity.SubjectOf)
select entity;
/// <summary>
/// Filters the sequence of IVerbal constructs selecting those with at least one bound subject.
/// </summary>
/// <typeparam name="TVerbal">Any Type which implements the IVerbal interface.</typeparam>
/// <param name="verbals">The Enumerable of T instances to filter.</param>
/// <returns>The subset bound to some subject.</returns>
public static ParallelQuery <TVerbal> WithSubject <TVerbal>(this ParallelQuery <TVerbal> verbals)
where TVerbal : IVerbal => verbals.Where(verbal => verbal.HasSubject());
public static void Union_Unordered_SourceMultiple(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int count)
{
// The difference between this test and the previous, is that it's not possible to
// get non-unique results from ParallelEnumerable.Range()...
// Those tests either need modification of source (via .Select(x => x / DuplicateFactor) or similar,
// or via a comparator that considers some elements equal.
_ = leftCount;
_ = rightCount;
IntegerRangeSet seen = new IntegerRangeSet(0, count);
Assert.All(leftQuery.Union(rightQuery), x => seen.Add(x));
seen.AssertComplete();
}
public static void Except_Distinct_Longrunning(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int start, int count)
{
Except_Distinct(left, leftCount, rightQuery, rightCount, start, count);
}
public static void Union_SourceMultiple(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int count)
{
_ = leftCount;
_ = rightCount;
int seen = 0;
Assert.All(leftQuery.AsOrdered().Union(rightQuery.AsOrdered()), x => Assert.Equal(seen++, x));
Assert.Equal(count, seen);
}
public static void Intersect_NotPipelined(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
ParallelQuery<int> leftQuery = left.Item;
int seen = 0;
Assert.All(leftQuery.Intersect(rightQuery).ToList(), x => Assert.Equal(seen++, x));
Assert.Equal(count, seen);
}
public static void Union_SourceMultiple_Longrunning(ParallelQuery <int> leftQuery, int leftCount, ParallelQuery <int> rightQuery, int rightCount, int count)
{
Union_SourceMultiple(leftQuery, leftCount, rightQuery, rightCount, count);
}
public static void Intersect_Distinct_NotPipelined(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
ParallelQuery<int> leftQuery = left.Item;
leftCount = Math.Min(DuplicateFactor * 2, leftCount);
rightCount = Math.Min(DuplicateFactor, (rightCount + 1) / 2);
int seen = 0;
Assert.All(leftQuery.Intersect(rightQuery.Select(x => Math.Abs(x) % DuplicateFactor), new ModularCongruenceComparer(DuplicateFactor * 2)).ToList(), x => Assert.Equal(seen++, x));
Assert.Equal(Math.Min(leftCount, rightCount), seen);
}
public Hero GetModifierHero(ParallelQuery <Hero> allies)
{
return
(allies.Where(x => x.HasModifier(abilityModifier.Name)).OrderByDescending(x => x.Health).FirstOrDefault());
}
public static void Intersect(Labeled<ParallelQuery<int>> left, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
ParallelQuery<int> leftQuery = left.Item;
int seen = 0;
foreach (int i in leftQuery.Intersect(rightQuery))
{
Assert.Equal(seen++, i);
}
Assert.Equal(count, seen);
}
public static void All_AllFalse(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(count == 0, query.All(x => x < 0));
}
public static void Distinct_SourceMultiple(ParallelQuery<int> query, int count)
{
int seen = 0;
Assert.All(query.Distinct(), x => Assert.Equal(seen++, x));
Assert.Equal(count, seen);
}
public static void All_OneTrue(Labeled <ParallelQuery <int> > labeled, int count, int position)
{
ParallelQuery <int> query = labeled.Item;
Assert.False(query.All(x => x == position));
}
public static void Intersect_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
int seen = 0;
Assert.All(leftQuery.Intersect(rightQuery), x => Assert.Equal(seen++, x));
Assert.Equal(count, seen);
}
/// <summary>
///
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
public static ParallelQuery <XElement> RemoveRsidAttributes(this ParallelQuery <XElement> elements)
{
return(elements.Select(x => x.RemoveRsidAttributes()));
}
public static void Except_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int start, int count)
{
int seen = start;
Assert.All(leftQuery.Except(rightQuery), x => Assert.Equal(seen++, x));
Assert.Equal(start + count, seen);
}
public static void Last_Empty(Labeled <ParallelQuery <int> > labeled, int count, int position)
{
ParallelQuery <int> query = labeled.Item;
Assert.Throws <InvalidOperationException>(() => query.Last());
}
public static void Union_Unordered_SourceMultiple(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
// The difference between this test and the previous, is that it's not possible to
// get non-unique results from ParallelEnumerable.Range()...
// Those tests either need modification of source (via .Select(x => x / DuplicateFactor) or similar,
// or via a comparator that considers some elements equal.
IntegerRangeSet seen = new IntegerRangeSet(0, count);
Assert.All(leftQuery.Union(rightQuery), x => seen.Add(x));
seen.AssertComplete();
}
public static void LastOrDefault_Empty(Labeled <ParallelQuery <int> > labeled, int count, int position)
{
ParallelQuery <int> query = labeled.Item;
Assert.Equal(default(int), query.LastOrDefault());
}
public static void Union_SourceMultiple_Longrunning(ParallelQuery<int> leftQuery, int leftCount, ParallelQuery<int> rightQuery, int rightCount, int count)
{
Union_SourceMultiple(leftQuery, leftCount, rightQuery, rightCount, count);
}
public static void OfType_NoneValid(Labeled <ParallelQuery <int> > labeled, int count)
{
ParallelQuery <int> query = labeled.Item;
Assert.Empty(query.OfType <long>());
}
