public void GetEnumeratorExplicit()
{
ICollection <int> builder = ImmutableSegmentedList.Create <int>().ToBuilder();
var enumerator = builder.GetEnumerator();
Assert.NotNull(enumerator);
}
public void RemoveRangeEnumerableTest()
{
var list = ImmutableSegmentedList.Create(1, 2, 3);
Assert.Throws <ArgumentNullException>("items", () => list.RemoveRange(null !));
ImmutableSegmentedList <int> removed2 = list.RemoveRange(new[] { 2 });
Assert.Equal(2, removed2.Count);
Assert.Equal(new[] { 1, 3 }, removed2);
ImmutableSegmentedList <int> removed13 = list.RemoveRange(new[] { 1, 3, 5 });
Assert.Equal(1, removed13.Count);
Assert.Equal(new[] { 2 }, removed13);
Assert.Equal(new[] { 2 }, System.Collections.Immutable.ImmutableList.RemoveRange((System.Collections.Immutable.IImmutableList <int>)list, new[] { 1, 3, 5 }));
Assert.True(IsSame(list, list.RemoveRange(new[] { 5 })));
Assert.True(IsSame(ImmutableSegmentedList.Create <int>(), ImmutableSegmentedList.Create <int>().RemoveRange(new[] { 1 })));
var listWithDuplicates = ImmutableSegmentedList.Create(1, 2, 2, 3);
Assert.Equal(new[] { 1, 2, 3 }, listWithDuplicates.RemoveRange(new[] { 2 }));
Assert.Equal(new[] { 1, 3 }, listWithDuplicates.RemoveRange(new[] { 2, 2 }));
Assert.Throws <ArgumentNullException>("items", () => System.Collections.Immutable.ImmutableList.RemoveRange((System.Collections.Immutable.IImmutableList <int>)ImmutableSegmentedList.Create(1, 2, 3), null !));
Assert.Equal(new[] { 1, 3 }, System.Collections.Immutable.ImmutableList.RemoveRange((System.Collections.Immutable.IImmutableList <int>)ImmutableSegmentedList.Create(1, 2, 3), new[] { 2 }));
}
public void InsertBalanceTest()
{
var list = ImmutableSegmentedList.Create(1);
list = list.Insert(0, 2);
list = list.Insert(1, 3);
}
public static void TestDebuggerAttributes_Null()
{
Type proxyType = DebuggerAttributes.GetProxyType(ImmutableSegmentedList.Create <double>());
TargetInvocationException tie = Assert.Throws <TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object?)null));
Assert.IsType <ArgumentNullException>(tie.InnerException);
}
public void CopyToTest()
{
var list = ImmutableSegmentedList.Create(1, 2);
var enumerable = (IEnumerable <int>)list;
var array = new int[2];
CopyToImpl(list, array);
Assert.Equal(enumerable, array);
array = new int[2];
CopyToImpl(list, array, 0);
Assert.Equal(enumerable, array);
array = new int[2];
CopyToImpl(list, 0, array, 0, list.Count);
Assert.Equal(enumerable, array);
array = new int[1]; // shorter than source length
CopyToImpl(list, 0, array, 0, array.Length);
Assert.Equal(enumerable.Take(array.Length), array);
array = new int[3];
CopyToImpl(list, 1, array, 2, 1);
Assert.Equal(new[] { 0, 0, 2 }, array);
array = new int[2];
((ICollection)GetListQuery(list)).CopyTo(array, 0);
Assert.Equal(enumerable, array);
}
public void RemoveRange_EnumerableEqualityComparer_AcceptsNullEQ()
{
var list = ImmutableSegmentedList.Create(1, 2, 3);
var removed2eq = list.RemoveRange(new[] { 2 }, null);
Assert.Equal(2, removed2eq.Count);
Assert.Equal(new[] { 1, 3 }, removed2eq);
}
public void ReverseTest2()
{
var emptyList = ImmutableSegmentedList.Create <int>();
Assert.True(IsSame(emptyList, emptyList.Reverse()));
var populatedList = ImmutableSegmentedList.Create(3, 2, 1);
Assert.Equal(Enumerable.Range(1, 3), populatedList.Reverse());
}
/// <summary>
/// Asserts that the <see cref="ImmutableSegmentedList{T}"/> or <see cref="ImmutableSegmentedList{T}.Builder"/>'s
/// implementation of <see cref="IList"/> behave the same way <see cref="List{T}"/> does.
/// </summary>
/// <typeparam name="T">The type of the element for one collection to test with.</typeparam>
/// <param name="operation">
/// The <see cref="IList"/> operation to perform.
/// The function is provided with the <see cref="IList"/> implementation to test
/// and the item to use as the argument to the operation.
/// The function should return some equatable value by which to compare the effects
/// of the operation across <see cref="IList"/> implementations.
/// </param>
/// <param name="item">The item to add to the collection.</param>
/// <param name="other">The item to pass to the <paramref name="operation"/> function as the second parameter.</param>
protected void AssertIListBaseline <T>(Func <IList, object?, object> operation, T item, object?other)
{
IList bclList = new List <T> {
item
};
IList testedList = (IList)this.GetListQuery(ImmutableSegmentedList.Create(item));
object expected = operation(bclList, other);
object actual = operation(testedList, other);
Assert.Equal(expected, actual);
}
public void IListOfTIsReadOnly()
{
IList <int> list = ImmutableSegmentedList.Create <int>();
Assert.True(list.IsReadOnly);
Assert.Throws <NotSupportedException>(() => list.Add(1));
Assert.Throws <NotSupportedException>(() => list.Clear());
Assert.Throws <NotSupportedException>(() => list.Insert(0, 1));
Assert.Throws <NotSupportedException>(() => list.Remove(1));
Assert.Throws <NotSupportedException>(() => list.RemoveAt(0));
Assert.Throws <NotSupportedException>(() => list[0] = 1);
}
public void Remove_NullEqualityComparer()
{
var collection = ImmutableSegmentedList.Create(1, 2, 3);
var modified = collection.Remove(2, null);
Assert.Equal(new[] { 1, 3 }, modified);
// Try again through the explicit interface implementation.
System.Collections.Immutable.IImmutableList <int> collectionIface = collection;
var modified2 = collectionIface.Remove(2, null);
Assert.Equal(new[] { 1, 3 }, modified2);
}
public void RemoveRangeArrayTest()
{
Assert.True(ImmutableSegmentedList <int> .Empty.RemoveRange(0, 0).IsEmpty);
var list = ImmutableSegmentedList.Create(1, 2, 3);
Assert.Throws <ArgumentOutOfRangeException>("index", () => list.RemoveRange(-1, 0));
Assert.Throws <ArgumentOutOfRangeException>("count", () => list.RemoveRange(0, -1));
Assert.Throws <ArgumentException>(() => list.RemoveRange(4, 0));
Assert.Throws <ArgumentException>(() => list.RemoveRange(0, 4));
Assert.Throws <ArgumentException>(() => list.RemoveRange(2, 2));
Assert.Equal(list, list.RemoveRange(3, 0));
}
public void DebuggerAttributesValid()
{
DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableSegmentedList.Create <int>());
ImmutableSegmentedList <double> list = ImmutableSegmentedList.Create <double>(1, 2, 3);
DebuggerAttributeInfo info = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(list);
object?rootNode = DebuggerAttributes.GetFieldValue(ImmutableSegmentedList.Create <string>("1", "2", "3"), "_root") !;
DebuggerAttributes.ValidateDebuggerDisplayReferences(rootNode);
PropertyInfo itemProperty = info.Properties.Single(pr => pr.GetCustomAttribute <DebuggerBrowsableAttribute>() !.State == DebuggerBrowsableState.RootHidden);
double[]? items = itemProperty.GetValue(info.Instance) as double[];
Assert.Equal(list, items);
}
public void SetItem()
{
var emptyList = ImmutableSegmentedList.Create <int>();
Assert.Throws <ArgumentOutOfRangeException>("index", () => emptyList[-1]);
Assert.Throws <ArgumentOutOfRangeException>("index", () => emptyList[0]);
Assert.Throws <ArgumentOutOfRangeException>("index", () => emptyList[1]);
var listOfOne = emptyList.Add(5);
Assert.Throws <ArgumentOutOfRangeException>("index", () => listOfOne[-1]);
Assert.Equal(5, listOfOne[0]);
Assert.Throws <ArgumentOutOfRangeException>("index", () => listOfOne[1]);
}
public void Create()
{
var comparer = StringComparer.OrdinalIgnoreCase;
ImmutableSegmentedList <string> list = ImmutableSegmentedList.Create <string>();
Assert.Equal(0, list.Count);
list = ImmutableSegmentedList.Create("a");
Assert.Equal(1, list.Count);
list = ImmutableSegmentedList.Create("a", "b");
Assert.Equal(2, list.Count);
list = ImmutableSegmentedList.CreateRange((IEnumerable <string>) new[] { "a", "b" });
Assert.Equal(2, list.Count);
}
public void InsertRangeImmutableTest()
{
var list = ImmutableSegmentedList <int> .Empty;
var nonEmptyList = ImmutableSegmentedList.Create(1);
Assert.Throws <ArgumentOutOfRangeException>("index", () => list.InsertRange(1, nonEmptyList));
Assert.Throws <ArgumentOutOfRangeException>("index", () => list.InsertRange(-1, nonEmptyList));
list = list.InsertRange(0, ImmutableSegmentedList.Create(1, 104, 105));
list = list.InsertRange(1, ImmutableSegmentedList.Create(2, 3));
list = list.InsertRange(2, ImmutableSegmentedList <int> .Empty);
list = list.InsertRange(3, ImmutableSegmentedList <int> .Empty.InsertRange(0, Enumerable.Range(4, 100)));
Assert.Equal(Enumerable.Range(1, 105), list);
Assert.Throws <ArgumentOutOfRangeException>("index", () => list.InsertRange(106, nonEmptyList));
Assert.Throws <ArgumentOutOfRangeException>("index", () => list.InsertRange(-1, nonEmptyList));
}
public void AddRangeOptimizationsTest()
{
// All these optimizations are tested based on filling an empty list.
var emptyList = ImmutableSegmentedList.Create <string>();
// Adding an empty list to an empty list should yield the original list.
Assert.True(IsSame(emptyList, emptyList.AddRange(new string[0])));
// Adding a non-empty immutable list to an empty one should return the added list.
var nonEmptyListDefaultComparer = ImmutableSegmentedList.Create("5");
Assert.True(IsSame(nonEmptyListDefaultComparer, emptyList.AddRange(nonEmptyListDefaultComparer)));
// Adding a Builder instance to an empty list should be seen through.
var builderOfNonEmptyListDefaultComparer = nonEmptyListDefaultComparer.ToBuilder();
Assert.True(IsSame(nonEmptyListDefaultComparer, emptyList.AddRange(builderOfNonEmptyListDefaultComparer)));
}
public void IListMembers()
{
IList list = ImmutableSegmentedList.Create <int>().ToBuilder();
Assert.False(list.IsReadOnly);
Assert.False(list.IsFixedSize);
Assert.Equal(0, list.Add(5));
Assert.Equal(1, list.Add(8));
Assert.True(list.Contains(5));
Assert.False(list.Contains(7));
list.Insert(1, 6);
Assert.Equal(6, list[1]);
list.Remove(5);
list[0] = 9;
Assert.Equal(new[] { 9, 8 }, list.Cast <int>().ToArray());
list.Clear();
Assert.Equal(0, list.Count);
}
public void EnumeratorTest()
{
var list = ImmutableSegmentedList.Create("a");
var enumerator = list.GetEnumerator();
Assert.Null(enumerator.Current);
Assert.True(enumerator.MoveNext());
Assert.Equal("a", enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Null(enumerator.Current);
enumerator.Reset();
Assert.Null(enumerator.Current);
Assert.True(enumerator.MoveNext());
Assert.Equal("a", enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Null(enumerator.Current);
enumerator.Dispose();
enumerator.Reset();
}
public void ReplaceWithEqualityComparerTest()
{
var list = ImmutableSegmentedList.Create(new Person {
Name = "Andrew", Age = 20
});
var newAge = new Person {
Name = "Andrew", Age = 21
};
var updatedList = list.Replace(newAge, newAge, new NameOnlyEqualityComparer());
Assert.Equal(newAge.Age, updatedList[0].Age);
// Try again with a null equality comparer, which should use the default EQ.
updatedList = list.Replace(list[0], newAge);
Assert.False(IsSame(list, updatedList));
// Finally, try one last time using the interface implementation.
System.Collections.Immutable.IImmutableList <Person> iface = list;
var updatedIface = System.Collections.Immutable.ImmutableList.Replace(iface, list[0], newAge);
Assert.NotSame(iface, updatedIface);
}
public void EnumeratorRecyclingMisuse()
{
var collection = ImmutableSegmentedList.Create(1);
var enumerator = collection.GetEnumerator();
var enumeratorCopy = enumerator;
Assert.True(enumerator.MoveNext());
enumerator.Dispose();
Assert.False(enumerator.MoveNext());
enumerator.Reset();
Assert.Equal(0, enumerator.Current);
Assert.True(enumeratorCopy.MoveNext());
enumeratorCopy.Reset();
Assert.Equal(0, enumeratorCopy.Current);
enumerator.Dispose(); // double-disposal should not throw
enumeratorCopy.Dispose();
// We expect that acquiring a new enumerator will use the same underlying Stack<T> object,
// but that it will not throw exceptions for the new enumerator.
enumerator = collection.GetEnumerator();
Assert.True(enumerator.MoveNext());
Assert.Equal(collection[0], enumerator.Current);
enumerator.Dispose();
}
public void IsReadOnly()
{
ICollection <int> builder = ImmutableSegmentedList.Create <int>().ToBuilder();
Assert.False(builder.IsReadOnly);
}
public void GetHashCodeVariesByInstance()
{
Assert.NotEqual(ImmutableSegmentedList.Create <int>().GetHashCode(), ImmutableSegmentedList.Create(5).GetHashCode());
}
public void ToImmutableListOfSameType()
{
var list = ImmutableSegmentedList.Create("a");
Assert.True(IsSame(list, list.ToImmutableSegmentedList()));
}
public void IsSynchronized()
{
ICollection collection = ImmutableSegmentedList.Create <int>();
Assert.True(collection.IsSynchronized);
}
