public void Test_Ordering<T>([PexAssumeNotNull] T[] array) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
Array.Sort(array);
Assert2.SequenceEqual(array, seq);
Array.Reverse(array);
Assert2.SequenceEqual(array, seq.ReverseIterator());
}
protected OrderedSequence(IAsyncEnumerable <TSource> source, bool descending, OrderedSequence <TSource>?parent)
{
Contract.Requires(source != null);
m_source = source;
m_descending = descending;
m_parent = parent;
}
protected readonly OrderedSequence <TSource>?m_parent; // null if primary sort key
public OrderedSequence(IAsyncEnumerable <TSource> source, IComparer <TSource>?comparer, bool descending, OrderedSequence <TSource>?parent)
{
Contract.Requires(source != null);
m_source = source;
m_descending = descending;
m_comparer = comparer;
m_parent = parent;
}
public void Test_MinMax<T>([PexAssumeNotNull] T[] array) where T : IComparable<T> {
PexAssume.IsNotNullOrEmpty(array);
var seq = OrderedSequence.FromEnumerable(array);
Array.Sort(array);
Assert.Equal(array[0], seq.Min);
Assert.Equal(array[array.Length - 1], seq.Max);
Assert2.SequenceEqual(array.Skip(1), seq.ExceptMin);
Assert2.SequenceEqual(array.Take(array.Length - 1), seq.ExceptMax);
}
public void Test_ExtractAll<T>([PexAssumeNotNull] T[] array, T item) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
var split = seq.ExtractAll(item);
Assert2.SequenceEqual(seq, split.Item1.Concat(split.Item2).Concat(split.Item3));
PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) < 0);
PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) == 0);
PexAssert.TrueForAll(split.Item3, t => t.CompareTo(item) > 0);
Assert2.SequenceEqual(split.Item1, seq.LessThan(item));
Assert2.SequenceEqual(split.Item1.Concat(split.Item2), seq.AtMost(item));
Assert2.SequenceEqual(split.Item2.Concat(split.Item3), seq.AtLeast(item));
Assert2.SequenceEqual(split.Item3, seq.GreaterThan(item));
}
public void Test_Split<T>([PexAssumeNotNull] T[] array, T item, bool equalGoLeft) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
var split = seq.Split(item, equalGoLeft);
Assert2.SequenceEqual(seq, split.Item1 + split.Item2);
if (equalGoLeft) {
PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) <= 0);
PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) > 0);
}
else {
PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) < 0);
PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) >= 0);
}
}
public void TestStringOrderedSequence()
{
var os = new OrderedSequence <string, string>(
new Key <string, string>(string.Empty, (s) => { return(s); }));
var src = new List <string>
{
"zaz",
"zab",
"zah",
"aaz",
"abz",
"acd",
"eeh",
"heh"
};
foreach (var s in src)
{
os = os.Insert(s);
}
var expected = new List <string>
{
"aaz",
"abz",
"acd",
"eeh",
"heh",
"zab",
"zah",
"zaz",
};
var tseq = os.ToSequence();
var tseqEnum = tseq.GetEnumerator();
tseqEnum.MoveNext();
foreach (var es in expected)
{
if (0 != es.CompareTo(tseqEnum.Current))
{
throw new Exception("TestStringOrderedSequence failed.");
}
tseqEnum.MoveNext();
}
}
public void TestCharOrderedSequence()
{
var os = new OrderedSequence <char, uint>(
new Key <char, uint>(uint.MinValue, (c) => { return(c); }));
var src = new List <char>
{
'z',
'b',
'h',
'a',
'a',
'c',
'e',
'j'
};
foreach (var s in src)
{
os = os.Insert(s);
}
var expected = new List <char>
{
'a',
'a',
'b',
'c',
'e',
'h',
'j',
'z',
};
var tseq = os.ToSequence();
var tseqEnum = tseq.GetEnumerator();
tseqEnum.MoveNext();
foreach (var es in expected)
{
if (0 != es.CompareTo(tseqEnum.Current))
{
throw new Exception("TestCharOrderedSequence failed.");
}
tseqEnum.MoveNext();
}
}
public void Test_Insert<T>([PexAssumeNotNull] T[] array1, [PexAssumeNotNull] T[] array2) where T : IComparable<T> {
var seq1 = OrderedSequence.FromEnumerable(array1);
var seq = seq1.InsertRange(array2);
Assert2.SequenceEqual(array1.Concat(array2).Sort(), seq);
}
public void Test_ContainsNegative<T>([PexAssumeNotNull] T[] array, T item) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
PexAssume.IsFalse(array.Contains(item));
Assert.DoesNotContain(item, seq);
Assert.False(seq[item].HasValue);
}
public void Test_ContainsPositive<T>([PexAssumeNotNull] T[] array, T item) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
PexAssume.IsTrue(array.Contains(item));
Assert.Contains(item, seq);
Assert.Equal(0, seq[item].Value.CompareTo(item));
}
public void Test_Intersect<T>([PexAssumeNotNull] T[] array1, [PexAssumeNotNull] T[] array2) where T : IComparable<T> {
var seq1 = OrderedSequence.FromEnumerable(array1);
var seq2 = OrderedSequence.FromEnumerable(array2);
Assert2.SequenceEqual(array1.Intersect(array2).Sort(), seq1.Intersect(seq2));
}
