public void GetEnumeratorShouldSortSource() { var source = new int[] {8, 4, 42, 23, 15, 16}; var orderedEnumerable = new OrderedEnumerable<int>(source, Comparer<int>.Default); orderedEnumerable.AssertSequenceEqual(4, 8, 15, 16, 23, 42); }
IOrderedEnumerable IOrderedEnumerable.CreateOrderedEnumerable <TKey>(Func <object, TKey> keySelector, IComparer comparer, bool descending) { OrderedEnumerable <TKey> result = new OrderedEnumerable <TKey>(this.source, keySelector, comparer, descending) { parent = this }; return(result); }
public void ConstructorWhenNoElementsShouldCreateEmptyOrderedEnumerable() { string[] testArray = { }; OrderedEnumerable <string, int> orderedList = (OrderedEnumerable <string, int>) new OrderedEnumerable <string, int>( testArray, fruit => fruit.Length, Comparer <int> .Default); Assert.Empty(orderedList); }
public void CreateOrderedEnumerableWhenNoElementsShouldReturnEmptySequence() { string[] testArray = { }; OrderedEnumerable <string, int> orderedList = (OrderedEnumerable <string, int>) new OrderedEnumerable <string, int>( testArray, fruit => fruit.Length, Comparer <int> .Default) .CreateOrderedEnumerable( x => 1, Comparer <int> .Default, false); Assert.Empty(orderedList); }
public void ConstructorWhenElementsShouldCreateOrderedEnumerable() { string[] testArray = { "apricot", "orange", "banana", "mango" }; OrderedEnumerable <string, int> orderedList = (OrderedEnumerable <string, int>) new OrderedEnumerable <string, int>( testArray, fruit => fruit.Length, Comparer <int> .Default); Assert.Collection(orderedList, item => Assert.Equal("mango", item), item => Assert.Equal("orange", item), item => Assert.Equal("banana", item), item => Assert.Equal("apricot", item)); }
internal OrderedEnumerable(IEnumerable <TElement> source, Func <TElement, TKey> keySelector, IComparer <TKey>?comparer, bool descending, OrderedEnumerable <TElement>?parent) : base(source) { if (source is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source); } if (keySelector is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keySelector); } _parent = parent; _keySelector = keySelector; _comparer = comparer ?? Comparer <TKey> .Default; _descending = descending; }
public void CreateOrderedEnumerableWhenMultipleCallsShouldReturnSubordinateOrderedSequence() { ListCollection <string[]> testList = new ListCollection <string[]>(); testList.Add(new[] { "E", "3", "C1", "2E" }); testList.Add(new[] { "D", "2", "A2", "1C" }); testList.Add(new[] { "C", "1", "D2", "1D" }); testList.Add(new[] { "A", "1", "C1", "2A" }); testList.Add(new[] { "B", "3", "D1", "4C" }); testList.Add(new[] { "A", "3", "D4", "3B" }); testList.Add(new[] { "C", "4", "A0", "0A" }); testList.Add(new[] { "C", "3", "D4", "3B" }); testList.Add(new[] { "B", "3", "C0", "4C" }); testList.Add(new[] { "E", "3", "C1", "2B" }); OrderedEnumerable <string[], string> orderedList = (OrderedEnumerable <string[], string>) new OrderedEnumerable <string[], string>( testList, x => x[0], Comparer <string> .Default). CreateOrderedEnumerable( x => x[1], Comparer <string> .Default, false). CreateOrderedEnumerable( x => x[2], Comparer <string> .Default, false). CreateOrderedEnumerable( x => x[3], Comparer <string> .Default, false); Assert.Collection(orderedList, item => Assert.Equal(new[] { "A", "1", "C1", "2A" }, item), item => Assert.Equal(new[] { "A", "3", "D4", "3B" }, item), item => Assert.Equal(new[] { "B", "3", "C0", "4C" }, item), item => Assert.Equal(new[] { "B", "3", "D1", "4C" }, item), item => Assert.Equal(new[] { "C", "1", "D2", "1D" }, item), item => Assert.Equal(new[] { "C", "3", "D4", "3B" }, item), item => Assert.Equal(new[] { "C", "4", "A0", "0A" }, item), item => Assert.Equal(new[] { "D", "2", "A2", "1C" }, item), item => Assert.Equal(new[] { "E", "3", "C1", "2B" }, item), item => Assert.Equal(new[] { "E", "3", "C1", "2E" }, item)); }
public void AsOrderedLikeGrouping() { OrderedEnumerable <int, string> parent = Enumerable.Range(0, 1).AsOrderedBy(n => n.ToString(), new StringComparer()); IEnumerable <IGrouping <string, int> > source = new[] { new Grouping <string, int>("0", Enumerable.Range(0, 1)) }; OrderedEnumerable <OrderedGrouping <string, int>, string> ordered = source.AsOrderedLike(parent); //Assert.That(ordered.Source, Is.EqualTo()); //Assert.That(ordered.KeySelector, Is.EqualTo(group => group.Key)); Assert.That(ordered.KeyComparer, Is.EqualTo(parent.KeyComparer)); Assert.That(ordered.Descending, Is.EqualTo(parent.Descending)); OrderedGrouping <string, int> firstGroup = ordered.First(); Assert.That(firstGroup.Source, Is.EqualTo(new[] { 0 })); Assert.That(firstGroup.KeySelector, Is.EqualTo(parent.KeySelector)); Assert.That(firstGroup.KeyComparer, Is.EqualTo(parent.KeyComparer)); Assert.That(firstGroup.Descending, Is.EqualTo(parent.Descending)); }
public void CreateOrderedEnumerableWhenElementsShouldReturnSubordinateOrderedSequence() { string[] testArray = { "apricot", "orange", "banana", "mango", "apple", "grape", "strawberry" }; OrderedEnumerable <string, int> orderedList = (OrderedEnumerable <string, int>) new OrderedEnumerable <string, int>( testArray, fruit => fruit.Length, Comparer <int> .Default) .CreateOrderedEnumerable( fruit => fruit, Comparer <string> .Default, false); Assert.Collection(orderedList, item => Assert.Equal("apple", item), item => Assert.Equal("grape", item), item => Assert.Equal("mango", item), item => Assert.Equal("banana", item), item => Assert.Equal("orange", item), item => Assert.Equal("apricot", item), item => Assert.Equal("strawberry", item)); }
public void ConstructorWhenRepeatedElementsShouldCreateStableOrderedEnumerable() { ListCollection <string[]> testList = new ListCollection <string[]>(); testList.Add(new string[] { "apricot", "1" }); testList.Add(new string[] { "orange", "1" }); testList.Add(new string[] { "apricot", "2" }); testList.Add(new string[] { "banana", "1" }); testList.Add(new string[] { "mango", "1" }); OrderedEnumerable <string[], int> orderedList = (OrderedEnumerable <string[], int>) new OrderedEnumerable <string[], int>( testList, fruit => fruit[0].Length, Comparer <int> .Default); Assert.Collection(orderedList, item => Assert.Equal(new string[] { "mango", "1" }, item), item => Assert.Equal(new string[] { "orange", "1" }, item), item => Assert.Equal(new string[] { "banana", "1" }, item), item => Assert.Equal(new string[] { "apricot", "1" }, item), item => Assert.Equal(new string[] { "apricot", "2" }, item)); }
public OrderedPartition(OrderedEnumerable <TElement> source, int minIdxInclusive, int maxIdxInclusive) { _source = source; _minIndexInclusive = minIdxInclusive; _maxIndexInclusive = maxIdxInclusive; }
private static OrderedEnumerable <TSource> AppendOrderedEnumerable <TSource, TKey>(OrderedEnumerable <TSource> parent, List <TKey> keys, IComparer <TKey> comparer, bool descending) { return(parent.CreateOrderedEnumerable(keys, comparer, descending)); }