public void TestImmutableSortedTreeSetCreateRange()
{
var values = new[] { Generator.GetInt32(), Generator.GetInt32(), Generator.GetInt32() };
var set = ImmutableSortedTreeSet.CreateRange(values);
Assert.Equal(values.OrderBy(x => x), set);
}
public void TestImmutableSortedTreeSetCreateRangeValidation()
{
Assert.Throws <ArgumentNullException>("other", () => ImmutableSortedTreeSet.CreateRange <int>(null !));
Assert.Throws <ArgumentNullException>("other", () => ImmutableSortedTreeSet.CreateRange(Comparer <int> .Default, null !));
Assert.Throws <ArgumentNullException>("source", () => default(IEnumerable <int>) !.ToImmutableSortedTreeSet());
Assert.Throws <ArgumentNullException>("source", () => default(IEnumerable <int>) !.ToImmutableSortedTreeSet(Comparer <int> .Default));
}
public void TestTrimExcess()
{
var random = new Random();
ImmutableSortedTreeSet <int> .Builder set = ImmutableSortedTreeSet.CreateBuilder <int>();
var reference = new SortedSet <int>();
for (int i = 0; i < 2 * 4 * 4; i++)
{
int value = random.Next(set.Count + 1);
set.Add(i);
reference.Add(i);
}
set.Validate(ValidationRules.None);
// In the first call to TrimExcess, items will move
set.TrimExcess();
set.Validate(ValidationRules.RequirePacked);
Assert.Equal(reference, set);
// In the second call, the list is already packed so nothing will move
set.TrimExcess();
set.Validate(ValidationRules.RequirePacked);
Assert.Equal(reference, set);
ImmutableSortedTreeSet <int> .Builder empty = ImmutableSortedTreeSet.CreateBuilder <int>();
empty.Validate(ValidationRules.RequirePacked);
empty.TrimExcess();
empty.Validate(ValidationRules.RequirePacked);
var single = ImmutableSortedTreeSet.CreateRange <int>(Enumerable.Range(0, 1)).ToBuilder();
single.Validate(ValidationRules.RequirePacked);
single.TrimExcess();
single.Validate(ValidationRules.RequirePacked);
// Construct a poorly-packed list with several levels
ImmutableSortedTreeSet <int> .Builder binary = ImmutableSortedTreeSet.CreateBuilder <int>();
for (int i = 99; i >= 0; i--)
{
binary.Add(i);
}
binary.TrimExcess();
binary.Validate(ValidationRules.RequirePacked);
// Construct a poorly-packed list with several levels
var ternary = ImmutableSortedTreeSet.CreateRange <int>(comparer: null, Enumerable.Range(0, 100)).ToBuilder();
for (int i = 99; i >= 0; i--)
{
ternary.Add(i);
}
ternary.TrimExcess();
ternary.Validate(ValidationRules.RequirePacked);
}
public void TestRemoveValue()
{
var set = ImmutableSortedTreeSet.CreateRange(comparer: null, Enumerable.Range(0, 10)).ToBuilder();
Assert.False(set.Remove(-1));
Assert.Equal(10, set.Count);
Assert.True(set.Remove(3));
Assert.Equal(9, set.Count);
}
public void TestCopyToValidation()
{
var set = ImmutableSortedTreeSet.CreateRange <int>(Enumerable.Range(0, 10)).ToBuilder();
Assert.Throws <ArgumentNullException>("array", () => ((ICollection <int>)set).CopyTo(array: null !, 0));
Assert.Throws <ArgumentOutOfRangeException>("arrayIndex", () => ((ICollection <int>)set).CopyTo(new int[set.Count], -1));
Assert.Throws <ArgumentException>(string.Empty, () => ((ICollection <int>)set).CopyTo(new int[set.Count - 1], 0));
Assert.Throws <ArgumentException>(string.Empty, () => ((ICollection <int>)set).CopyTo(new int[set.Count], 1));
}
public void TestMinMax()
{
Assert.Equal(0, ImmutableSortedTreeSet.CreateBuilder <int>().Min);
Assert.Equal(0, ImmutableSortedTreeSet.CreateBuilder <int>().Max);
Assert.Null(ImmutableSortedTreeSet.CreateBuilder <object>().Min);
Assert.Null(ImmutableSortedTreeSet.CreateBuilder <object>().Max);
var set = ImmutableSortedTreeSet.CreateRange(Enumerable.Range(0, 100).Select(x => Generator.GetInt32())).ToBuilder();
Assert.Equal(set.Min(), set.Min);
Assert.Equal(set.Max(), set.Max);
}
public void TestExplicitComparer()
{
var objComparer = new ComparisonComparer <object>((x, y) => 0);
var intComparer = new ComparisonComparer <int>((x, y) => 0);
var comparableComparer = new ComparisonComparer <IComparable>((x, y) => 0);
Assert.Same(objComparer, ImmutableSortedTreeSet.CreateBuilder <object>(comparer: objComparer).KeyComparer);
Assert.Same(intComparer, ImmutableSortedTreeSet.CreateBuilder <int>(comparer: intComparer).KeyComparer);
Assert.Same(comparableComparer, ImmutableSortedTreeSet.CreateBuilder <IComparable>(comparer: comparableComparer).KeyComparer);
Assert.Same(objComparer, ImmutableSortedTreeSet.CreateRange <object>(comparer: objComparer, Enumerable.Empty <object>()).ToBuilder().KeyComparer);
Assert.Same(intComparer, ImmutableSortedTreeSet.CreateRange <int>(comparer: intComparer, Enumerable.Empty <int>()).ToBuilder().KeyComparer);
Assert.Same(comparableComparer, ImmutableSortedTreeSet.CreateRange <IComparable>(comparer: comparableComparer, Enumerable.Empty <IComparable>()).ToBuilder().KeyComparer);
}
public void TestCopyTo()
{
var set = ImmutableSortedTreeSet.CreateRange(comparer: null, Enumerable.Range(0, 100)).ToBuilder();
var reference = new SortedSet <int>(Enumerable.Range(0, 100));
int[] listArray = new int[set.Count * 2];
int[] referenceArray = new int[reference.Count * 2];
((ICollection <int>)set).CopyTo(listArray, 0);
reference.CopyTo(referenceArray);
Assert.Equal(referenceArray, listArray);
((ICollection <int>)set).CopyTo(listArray, set.Count / 2);
reference.CopyTo(referenceArray, reference.Count / 2);
Assert.Equal(referenceArray, listArray);
}
public void TestICollectionTInterface()
{
ICollection <int> set = ImmutableSortedTreeSet.CreateRange(Enumerable.Range(0, 10)).ToBuilder();
Assert.False(set.IsReadOnly);
Assert.Equal(10, set.Count);
Assert.True(set.Contains(3));
set.Add(3);
Assert.True(set.Contains(3));
Assert.Equal(10, set.Count);
Assert.False(set.Contains(12));
set.Add(12);
Assert.True(set.Contains(12));
Assert.Equal(11, set.Count);
}
public void TestDefaultComparer()
{
Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.CreateBuilder <object>().KeyComparer);
Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.CreateBuilder <int>().KeyComparer);
Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.CreateBuilder <IComparable>().KeyComparer);
Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.CreateRange <object>(Enumerable.Empty <object>()).ToBuilder().KeyComparer);
Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.CreateRange <int>(Enumerable.Empty <int>()).ToBuilder().KeyComparer);
Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.CreateRange <IComparable>(Enumerable.Empty <IComparable>()).ToBuilder().KeyComparer);
Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.CreateBuilder <object>(comparer: null).KeyComparer);
Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.CreateBuilder <int>(comparer: null).KeyComparer);
Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.CreateBuilder <IComparable>(comparer: null).KeyComparer);
Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.CreateRange <object>(comparer: null, Enumerable.Empty <object>()).ToBuilder().KeyComparer);
Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.CreateRange <int>(comparer: null, Enumerable.Empty <int>()).ToBuilder().KeyComparer);
Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.CreateRange <IComparable>(comparer: null, Enumerable.Empty <IComparable>()).ToBuilder().KeyComparer);
}
protected override IEnumerable <T> TransformEnumerableForSetOperation <T>(IEnumerable <T> enumerable)
{
return(ImmutableSortedTreeSet.CreateRange(enumerable));
}
