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;
}
