public void TestImmutableTreeSetCreateRangeValidation() { Assert.Throws <ArgumentNullException>("other", () => ImmutableTreeSet.CreateRange <int>(null !)); Assert.Throws <ArgumentNullException>("other", () => ImmutableTreeSet.CreateRange(EqualityComparer <int> .Default, null !)); Assert.Throws <ArgumentNullException>("source", () => default(IEnumerable <int>) !.ToImmutableTreeSet()); Assert.Throws <ArgumentNullException>("source", () => default(IEnumerable <int>) !.ToImmutableTreeSet(EqualityComparer <int> .Default)); }
public void TestImmutableTreeSetCreateRange() { var values = new[] { Generator.GetInt32(), Generator.GetInt32(), Generator.GetInt32() }; var set = ImmutableTreeSet.CreateRange(values); Assert.Equal(values.OrderBy(x => x), set); }
public void TestTrimExcess() { var random = new Random(); ImmutableTreeSet <int> .Builder set = ImmutableTreeSet.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); ImmutableTreeSet <int> .Builder empty = ImmutableTreeSet.CreateBuilder <int>(); empty.Validate(ValidationRules.RequirePacked); empty.TrimExcess(); empty.Validate(ValidationRules.RequirePacked); var single = ImmutableTreeSet.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 ImmutableTreeSet <int> .Builder binary = ImmutableTreeSet.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 = ImmutableTreeSet.CreateRange <int>(equalityComparer: 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 = ImmutableTreeSet.CreateRange(equalityComparer: 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 = ImmutableTreeSet.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>(() => ((ICollection <int>)set).CopyTo(new int[set.Count], 1)); }
public void TestExplicitComparer() { ZeroHashCodeEqualityComparer <object> objComparer = ZeroHashCodeEqualityComparer <object> .Default; ZeroHashCodeEqualityComparer <int> intComparer = ZeroHashCodeEqualityComparer <int> .Default; ZeroHashCodeEqualityComparer <IComparable> comparableComparer = ZeroHashCodeEqualityComparer <IComparable> .Default; Assert.Same(objComparer, ImmutableTreeSet.CreateBuilder <object>(equalityComparer: objComparer).KeyComparer); Assert.Same(intComparer, ImmutableTreeSet.CreateBuilder <int>(equalityComparer: intComparer).KeyComparer); Assert.Same(comparableComparer, ImmutableTreeSet.CreateBuilder <IComparable>(equalityComparer: comparableComparer).KeyComparer); Assert.Same(objComparer, ImmutableTreeSet.CreateRange <object>(equalityComparer: objComparer, Enumerable.Empty <object>()).ToBuilder().KeyComparer); Assert.Same(intComparer, ImmutableTreeSet.CreateRange <int>(equalityComparer: intComparer, Enumerable.Empty <int>()).ToBuilder().KeyComparer); Assert.Same(comparableComparer, ImmutableTreeSet.CreateRange <IComparable>(equalityComparer: comparableComparer, Enumerable.Empty <IComparable>()).ToBuilder().KeyComparer); }
public void TestCopyTo() { var set = ImmutableTreeSet.CreateRange(equalityComparer: 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 = ImmutableTreeSet.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(EqualityComparer <object> .Default, ImmutableTreeSet.CreateBuilder <object>().KeyComparer); Assert.Same(EqualityComparer <int> .Default, ImmutableTreeSet.CreateBuilder <int>().KeyComparer); Assert.Same(EqualityComparer <IComparable> .Default, ImmutableTreeSet.CreateBuilder <IComparable>().KeyComparer); Assert.Same(EqualityComparer <object> .Default, ImmutableTreeSet.CreateRange <object>(Enumerable.Empty <object>()).ToBuilder().KeyComparer); Assert.Same(EqualityComparer <int> .Default, ImmutableTreeSet.CreateRange <int>(Enumerable.Empty <int>()).ToBuilder().KeyComparer); Assert.Same(EqualityComparer <IComparable> .Default, ImmutableTreeSet.CreateRange <IComparable>(Enumerable.Empty <IComparable>()).ToBuilder().KeyComparer); Assert.Same(EqualityComparer <object> .Default, ImmutableTreeSet.CreateBuilder <object>(equalityComparer: null).KeyComparer); Assert.Same(EqualityComparer <int> .Default, ImmutableTreeSet.CreateBuilder <int>(equalityComparer: null).KeyComparer); Assert.Same(EqualityComparer <IComparable> .Default, ImmutableTreeSet.CreateBuilder <IComparable>(equalityComparer: null).KeyComparer); Assert.Same(EqualityComparer <object> .Default, ImmutableTreeSet.CreateRange <object>(equalityComparer: null, Enumerable.Empty <object>()).ToBuilder().KeyComparer); Assert.Same(EqualityComparer <int> .Default, ImmutableTreeSet.CreateRange <int>(equalityComparer: null, Enumerable.Empty <int>()).ToBuilder().KeyComparer); Assert.Same(EqualityComparer <IComparable> .Default, ImmutableTreeSet.CreateRange <IComparable>(equalityComparer: null, Enumerable.Empty <IComparable>()).ToBuilder().KeyComparer); }
public void TestICollectionInterface() { TestICollectionInterfaceImpl(ImmutableTreeSet.Create(600, 601), supportsNullValues: false); TestICollectionInterfaceImpl(ImmutableTreeSet.Create <int?>(600, 601), supportsNullValues: true); TestICollectionInterfaceImpl(ImmutableTreeSet.Create <object>(600, 601), supportsNullValues: true); ICollection collection = ImmutableTreeSet <int> .Empty; collection.CopyTo(new int[0], 0); // Type checks are only performed if the collection has items collection.CopyTo(new string[0], 0); collection = ImmutableTreeSet.CreateRange(Enumerable.Range(0, 100)); var array = new int[collection.Count]; collection.CopyTo(array, 0); Assert.Equal(array, collection); // Run the same set of tests on ImmutableList<T> to ensure consistent behavior TestICollectionInterfaceImpl(ImmutableList.Create(600, 601), supportsNullValues: false); TestICollectionInterfaceImpl(ImmutableList.Create <int?>(600, 601), supportsNullValues: true); TestICollectionInterfaceImpl(ImmutableList.Create <object>(600, 601), supportsNullValues: true); }
protected override IEnumerable <T> TransformEnumerableForSetOperation <T>(IEnumerable <T> enumerable) { return(ImmutableTreeSet.CreateRange(enumerable)); }