internal override int FindLastIndex(TreeSpan span, Predicate <T> match) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); Debug.Assert(match != null, $"Assertion failed: {nameof(match)} != null"); return(_data.FindLastIndex(span.EndInclusive, span.Count, match)); }
internal override int FindLastIndex(TreeSpan span, Predicate <T> match) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); Debug.Assert(match != null, $"Assertion failed: {nameof(match)} != null"); return(-1); }
public void TestConstructor() { var treeSpan = new TreeSpan(50, 50); Assert.Equal(50, treeSpan.Start); Assert.Equal(50, treeSpan.Count); }
public void TestToString() { Assert.Equal("[50, 100)", new TreeSpan(50, 50).ToString()); Assert.Equal("[50, 100)", TreeSpan.FromBounds(50, 100).ToString()); Assert.Equal("[50, 100)", TreeSpan.FromReverseSpan(99, 50).ToString()); Assert.Equal("[-1, -1)", TreeSpan.Invalid.ToString()); }
internal override Node Sort(TreeSpan span, IComparer <T> comparer) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); Debug.Assert(comparer != null, $"Assertion failed: {nameof(comparer)} != null"); return(this); }
internal override int BinarySearch(TreeSpan span, T item, IComparer <T> comparer) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); Debug.Assert(comparer != null, $"Assertion failed: {nameof(comparer)} != null"); return(~0); }
public void TestEquals() { var treeSpan = new TreeSpan(50, 50); Assert.False(treeSpan.Equals(new object())); Assert.False(treeSpan.Equals(null)); Assert.False(treeSpan.Equals((object)TreeSpan.Invalid)); Assert.True(treeSpan.Equals((object)new TreeSpan(50, 50))); }
public void TestIEquatable() { IEquatable <TreeSpan> treeSpan = TreeSpan.Invalid; Assert.True(treeSpan.Equals(TreeSpan.Invalid)); treeSpan = new TreeSpan(50, 50); Assert.True(treeSpan.Equals(TreeSpan.FromBounds(50, 100))); }
internal Enumerator(ImmutableTreeList <T> list, TreeSpan span, Builder?builder) { _root = list._root; _span = span; _builder = builder; _version = builder?.Version ?? 0; _index = -1; _leafNode = null; _leafIndex = -1; _current = default !;
internal override Node Sort(TreeSpan span, IComparer <T> comparer) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); Debug.Assert(comparer != null, $"Assertion failed: {nameof(comparer)} != null"); LeafNode mutableNode = AsMutable(); mutableNode._data.Sort(span.Start, span.Count, comparer); return(mutableNode); }
public void TestIsProperSubspanOf() { Assert.True(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(35, 55))); Assert.True(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(35, 50))); Assert.True(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(40, 55))); Assert.False(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(40, 50))); Assert.False(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(35, 45))); Assert.False(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(45, 55))); Assert.False(TreeSpan.FromBounds(40, 50).IsProperSubspanOf(TreeSpan.FromBounds(41, 49))); }
public void TestOffset() { var treeSpan = new TreeSpan(50, 50); Assert.Equal(treeSpan, treeSpan.Offset(0)); var offset = treeSpan.Offset(5); Assert.Equal(new TreeSpan(55, 50), offset); Assert.Equal(treeSpan, offset.Offset(-5)); }
public void TestProperties() { var treeSpan = new TreeSpan(50, 50); Assert.False(treeSpan.IsEmpty); Assert.Equal(50, treeSpan.Start); Assert.Equal(50, treeSpan.Count); Assert.Equal(100, treeSpan.EndExclusive); Assert.Equal(99, treeSpan.EndInclusive); Assert.True(new TreeSpan(50, 0).IsEmpty); }
public void TestGetHashCode() { var treeSpan = new TreeSpan(14, 40); Assert.Equal(EqualityComparer <TreeSpan> .Default.GetHashCode(treeSpan), treeSpan.GetHashCode()); // Verify that the start position impacts the hash code (may need adjustment if the hash code algorithm changes) Assert.NotEqual(treeSpan.GetHashCode(), new TreeSpan(treeSpan.Start + 1, treeSpan.Count).GetHashCode()); // Verify that the count impacts the hash code (may need adjustment if the hash code algorithm changes) Assert.NotEqual(treeSpan.GetHashCode(), new TreeSpan(treeSpan.Start, treeSpan.Count + 1).GetHashCode()); }
public void TestIntersect() { var treeSpan = TreeSpan.Intersect(TreeSpan.Invalid, TreeSpan.Invalid); Assert.Equal(TreeSpan.Invalid, treeSpan); treeSpan = TreeSpan.Intersect(TreeSpan.FromBounds(45, 50), TreeSpan.FromBounds(50, 60)); Assert.Equal(TreeSpan.FromBounds(50, 50), treeSpan); treeSpan = TreeSpan.Intersect(TreeSpan.FromBounds(40, 45), TreeSpan.FromBounds(50, 55)); Assert.Equal(TreeSpan.Invalid, treeSpan); }
public void TestFromBounds() { var treeSpan = TreeSpan.FromBounds(50, 100); Assert.Equal(50, treeSpan.Start); Assert.Equal(100, treeSpan.EndExclusive); Assert.Equal(50, treeSpan.Count); treeSpan = TreeSpan.FromBounds(50, 50); Assert.Equal(50, treeSpan.Start); Assert.Equal(0, treeSpan.Count); Assert.True(treeSpan.IsEmpty); }
public void TestOperators() { #pragma warning disable CS1718 // Comparison made to same variable Assert.True(TreeSpan.Invalid == TreeSpan.Invalid); Assert.False(TreeSpan.Invalid != TreeSpan.Invalid); #pragma warning restore CS1718 // Comparison made to same variable Assert.True(new TreeSpan(50, 50) == TreeSpan.FromBounds(50, 100)); Assert.False(new TreeSpan(50, 50) != TreeSpan.FromBounds(50, 100)); Assert.False(new TreeSpan(0, 0) == TreeSpan.Invalid); Assert.True(new TreeSpan(0, 0) != TreeSpan.Invalid); }
public void TestPartialEnumeration() { Random random = new Random(1); TreeList <int> list = new TreeList <int>(branchingFactor: 4); List <int> reference = new List <int>(); for (int i = 0; i < 2 * 4 * 4; i++) { int index = random.Next(list.Count + 1); list.Insert(index, i); reference.Insert(index, i); } // Test a subsection of the list var listEnumerator = new TreeList <int> .Enumerator(list, TreeSpan.FromBounds(1, list.Count - 1)); IEnumerator <int> referenceEnumerator = reference.Skip(1).Take(reference.Count - 2).GetEnumerator(); TestEnumerators(referenceEnumerator, listEnumerator); // Test the first half listEnumerator = new TreeList <int> .Enumerator(list, TreeSpan.FromBounds(0, list.Count / 2)); referenceEnumerator = reference.Take(reference.Count / 2).GetEnumerator(); TestEnumerators(referenceEnumerator, listEnumerator); // Test the last half listEnumerator = new TreeList <int> .Enumerator(list, TreeSpan.FromBounds(list.Count / 2, list.Count)); referenceEnumerator = reference.Skip(reference.Count / 2).GetEnumerator(); TestEnumerators(referenceEnumerator, listEnumerator); void TestEnumerators(IEnumerator <int> expected, TreeList <int> .Enumerator actual) { Assert.Equal(referenceEnumerator.Current, listEnumerator.Current); while (true) { if (!referenceEnumerator.MoveNext()) { Assert.False(listEnumerator.MoveNext()); break; } Assert.True(listEnumerator.MoveNext()); Assert.Equal(referenceEnumerator.Current, listEnumerator.Current); } Assert.Equal(referenceEnumerator.Current, listEnumerator.Current); } }
internal Node Reverse(TreeSpan span) { Node newNode = this; int firstIndex = span.Start; int lastIndex = firstIndex + span.Count - 1; while (lastIndex > firstIndex) { T temp = newNode[firstIndex]; newNode = newNode.SetItem(firstIndex, newNode[lastIndex]); newNode = newNode.SetItem(lastIndex, temp); firstIndex++; lastIndex--; } return(newNode); }
public void TestFromReverseSpan() { var treeSpan = TreeSpan.FromReverseSpan(50, 1); Assert.Equal(50, treeSpan.Start); Assert.Equal(1, treeSpan.Count); Assert.Equal(51, treeSpan.EndExclusive); Assert.Equal(50, treeSpan.EndInclusive); treeSpan = TreeSpan.FromReverseSpan(50, 5); Assert.Equal(46, treeSpan.Start); Assert.Equal(5, treeSpan.Count); Assert.Equal(51, treeSpan.EndExclusive); Assert.Equal(50, treeSpan.EndInclusive); treeSpan = TreeSpan.FromReverseSpan(50, 0); Assert.Equal(51, treeSpan.Start); Assert.Equal(0, treeSpan.Count); Assert.Equal(51, treeSpan.EndExclusive); Assert.Equal(50, treeSpan.EndInclusive); }
internal override int IndexOf(T item, TreeSpan span, IEqualityComparer <T> equalityComparer) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); return(-1); }
internal abstract int LastIndexOf(T item, TreeSpan span, IEqualityComparer <T> equalityComparer);
internal abstract Node Sort(TreeSpan span, IComparer <T> comparer);
internal abstract int FindLastIndex(TreeSpan span, Predicate <T> match);
internal abstract int BinarySearch(TreeSpan span, T item, IComparer <T> comparer);
internal override int LastIndexOf(T item, TreeSpan span, IEqualityComparer <T> equalityComparer) { Debug.Assert(span.IsSubspanOf(Span), $"Assertion failed: {nameof(span)}.IsSubspanOf({nameof(Span)})"); return(_data.LastIndexOf(item, span.EndInclusive, span.Count, equalityComparer)); }
internal override int LastIndexOf(T item, TreeSpan span, IEqualityComparer <T> equalityComparer) { throw ExceptionUtilities.Unreachable; }