public void TestImmutableSortedTreeListCreateRangeValidation() { Assert.Throws <ArgumentNullException>("items", () => ImmutableSortedTreeList.CreateRange <int>(null !)); Assert.Throws <ArgumentNullException>("items", () => ImmutableSortedTreeList.CreateRange(Comparer <int> .Default, null !)); Assert.Throws <ArgumentNullException>("items", () => default(IEnumerable <int>) !.ToImmutableSortedTreeList()); Assert.Throws <ArgumentNullException>("items", () => default(IEnumerable <int>) !.ToImmutableSortedTreeList(Comparer <int> .Default)); }
public void TestImmutableSortedTreeListCreateRange() { var values = new[] { Generator.GetInt32(), Generator.GetInt32(), Generator.GetInt32() }; var list = ImmutableSortedTreeList.CreateRange(values); Assert.Equal(values.OrderBy(x => x), list); }
public void TestLastIndexOfInvalidOperations() { var single = ImmutableSortedTreeList.CreateRange(Enumerable.Range(1, 1)).ToBuilder(); Assert.Throws <ArgumentException>(() => single.LastIndexOf(0, 1, 0)); Assert.Throws <ArgumentOutOfRangeException>(() => single.LastIndexOf(0, 0, -1)); Assert.Throws <ArgumentOutOfRangeException>(() => single.LastIndexOf(0, 0, 2)); }
public void TestTrimExcess() { ImmutableSortedTreeList <int> .Builder list = ImmutableSortedTreeList.CreateBuilder <int>(); List <int> reference = new List <int>(); for (int i = 0; i < 4 * 8 * 8; i++) { int value = Generator.GetInt32(list.Count + 1); list.Add(i); reference.Add(i); } reference.Sort(); list.Validate(ValidationRules.None); // In the first call to TrimExcess, items will move list.TrimExcess(); list.Validate(ValidationRules.RequirePacked); Assert.Equal(reference, list); // In the second call, the list is already packed so nothing will move list.TrimExcess(); list.Validate(ValidationRules.RequirePacked); Assert.Equal(reference, list); ImmutableSortedTreeList <int> .Builder empty = ImmutableSortedTreeList.CreateBuilder <int>(); empty.Validate(ValidationRules.RequirePacked); empty.TrimExcess(); empty.Validate(ValidationRules.RequirePacked); var single = ImmutableSortedTreeList.CreateRange(Enumerable.Range(0, 1)).ToBuilder(); single.Validate(ValidationRules.RequirePacked); single.TrimExcess(); single.Validate(ValidationRules.RequirePacked); // Construct a poorly-packed list with several levels ImmutableSortedTreeList <int> .Builder binary = ImmutableSortedTreeList.CreateBuilder <int>(); for (int i = 5000; i >= 0; i--) { binary.Add(i); } binary.TrimExcess(); binary.Validate(ValidationRules.RequirePacked); // Construct a poorly-packed list with several levels ImmutableSortedTreeList <int> .Builder ternary = ImmutableSortedTreeList.CreateRange <int>(comparer: null, Enumerable.Range(0, 5000)).ToBuilder(); for (int i = 5000; i >= 0; i--) { ternary.Add(i); } ternary.TrimExcess(); ternary.Validate(ValidationRules.RequirePacked); }
public void TestRemoveValue() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(0, 10)).ToBuilder(); Assert.False(list.Remove(-1)); Assert.Equal(10, list.Count); Assert.True(list.Remove(3)); Assert.Equal(9, list.Count); }
public void TestIListTInterface() { IList <int> list = ImmutableSortedTreeList.CreateRange <int>(Enumerable.Range(0, 10)).ToBuilder(); Assert.False(list.IsReadOnly); Assert.Equal(0, list[0]); Assert.Throws <NotSupportedException>(() => list.Insert(0, 0)); }
public void TestRemoveAll() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(0, 10)).ToBuilder(); Assert.Throws <ArgumentNullException>(() => list.RemoveAll(null !)); Assert.Equal(5, list.RemoveAll(i => (i % 2) == 0)); Assert.Equal(new[] { 1, 3, 5, 7, 9 }, list); Assert.Equal(0, list.RemoveAll(i => i < 0)); Assert.Equal(5, list.Count); }
public void TestCopyToValidation() { var list = ImmutableSortedTreeList.CreateRange <int>(Enumerable.Range(0, 10)).ToBuilder(); Assert.Throws <ArgumentNullException>("array", () => list.CopyTo(0, null !, 0, list.Count)); Assert.Throws <ArgumentOutOfRangeException>("index", () => list.CopyTo(-1, new int[list.Count], 0, list.Count)); Assert.Throws <ArgumentOutOfRangeException>("arrayIndex", () => list.CopyTo(0, new int[list.Count], -1, list.Count)); Assert.Throws <ArgumentOutOfRangeException>("count", () => list.CopyTo(0, new int[list.Count], 0, -1)); Assert.Throws <ArgumentOutOfRangeException>(null, () => list.CopyTo(1, new int[list.Count], 0, list.Count)); Assert.Throws <ArgumentOutOfRangeException>(string.Empty, () => list.CopyTo(0, new int[list.Count], 1, list.Count)); }
public void TestIndexer() { var list = ImmutableSortedTreeList.CreateRange <int>(null, Enumerable.Range(0, 10)).ToBuilder(); Assert.Throws <ArgumentOutOfRangeException>(() => list[-1]); Assert.Throws <ArgumentOutOfRangeException>(() => list[list.Count]); Assert.Throws <NotSupportedException>(() => ((IList <int>)list)[-1] = 0); Assert.Throws <NotSupportedException>(() => ((IList <int>)list)[list.Count] = 0); for (int i = 0; i < list.Count; i++) { Assert.Equal(i, list[i]); } }
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, ImmutableSortedTreeList.CreateBuilder <object>(comparer: objComparer).Comparer); Assert.Same(intComparer, ImmutableSortedTreeList.CreateBuilder <int>(comparer: intComparer).Comparer); Assert.Same(comparableComparer, ImmutableSortedTreeList.CreateBuilder <IComparable>(comparer: comparableComparer).Comparer); Assert.Same(objComparer, ImmutableSortedTreeList.CreateRange <object>(comparer: objComparer, Enumerable.Empty <object>()).ToBuilder().Comparer); Assert.Same(intComparer, ImmutableSortedTreeList.CreateRange <int>(comparer: intComparer, Enumerable.Empty <int>()).ToBuilder().Comparer); Assert.Same(comparableComparer, ImmutableSortedTreeList.CreateRange <IComparable>(comparer: comparableComparer, Enumerable.Empty <IComparable>()).ToBuilder().Comparer); }
public void TestFind() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(1, 10)).ToBuilder(); Assert.Throws <ArgumentNullException>(() => list.Find(null !)); Assert.Equal(0, list.Find(value => value < 0)); foreach (var i in list) { Assert.Equal(i, list.Find(value => value == i)); } Assert.Equal(2, list.Find(value => value > 1)); }
public void TestFindAll() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(0, 10)).ToBuilder(); Assert.Throws <ArgumentNullException>(() => list.FindAll(null !)); ImmutableSortedTreeList <int> found = list.FindAll(i => (i % 2) == 0); Assert.Equal(10, list.Count); Assert.Equal(5, found.Count); Assert.Equal(new[] { 0, 2, 4, 6, 8 }, found); Assert.Empty(list.FindAll(i => i < 0)); }
public void TestExists() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(0, 10)).ToBuilder(); Assert.Throws <ArgumentNullException>(() => list.Exists(null !)); Assert.False(list.Exists(value => value < 0)); foreach (var i in list) { Assert.True(list.Exists(value => value == i)); } Assert.False(list.Exists(value => value > 10)); }
public void TestForEach() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(0, 100)).ToBuilder(); var reference = new List <int>(Enumerable.Range(0, 100)); Assert.Throws <ArgumentNullException>("action", () => list.ForEach(null !)); Assert.Throws <ArgumentNullException>(() => reference.ForEach(null !)); var listOutput = new List <int>(); var referenceOutput = new List <int>(); list.ForEach(listOutput.Add); reference.ForEach(referenceOutput.Add); Assert.Equal(referenceOutput, listOutput); }
public void TestFindLast() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(1, 10)).ToBuilder(); var reference = new List <int>(Enumerable.Range(1, 10)); Assert.Throws <ArgumentNullException>(() => list.FindLast(null !)); Assert.Equal(0, list.FindLast(i => i < 0)); Assert.Equal(0, reference.FindLast(i => i < 0)); Assert.Equal(10, list.FindLast(value => (value % 2) == 0)); Assert.Equal(10, reference.FindLast(value => (value % 2) == 0)); Assert.Equal(4, list.FindLast(value => value < 5)); Assert.Equal(4, reference.FindLast(value => value < 5)); }
public void TestDefaultComparer() { Assert.Same(Comparer <object> .Default, ImmutableSortedTreeList.CreateBuilder <object>().Comparer); Assert.Same(Comparer <int> .Default, ImmutableSortedTreeList.CreateBuilder <int>().Comparer); Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeList.CreateBuilder <IComparable>().Comparer); Assert.Same(Comparer <object> .Default, ImmutableSortedTreeList.CreateRange <object>(Enumerable.Empty <object>()).ToBuilder().Comparer); Assert.Same(Comparer <int> .Default, ImmutableSortedTreeList.CreateRange <int>(Enumerable.Empty <int>()).ToBuilder().Comparer); Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeList.CreateRange <IComparable>(Enumerable.Empty <IComparable>()).ToBuilder().Comparer); Assert.Same(Comparer <object> .Default, ImmutableSortedTreeList.CreateBuilder <object>(comparer: null).Comparer); Assert.Same(Comparer <int> .Default, ImmutableSortedTreeList.CreateBuilder <int>(comparer: null).Comparer); Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeList.CreateBuilder <IComparable>(comparer: null).Comparer); Assert.Same(Comparer <object> .Default, ImmutableSortedTreeList.CreateRange <object>(comparer: null, Enumerable.Empty <object>()).ToBuilder().Comparer); Assert.Same(Comparer <int> .Default, ImmutableSortedTreeList.CreateRange <int>(comparer: null, Enumerable.Empty <int>()).ToBuilder().Comparer); Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeList.CreateRange <IComparable>(comparer: null, Enumerable.Empty <IComparable>()).ToBuilder().Comparer); }
public void TestGetRange() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, Enumerable.Range(0, 100)).ToBuilder(); var reference = new List <int>(Enumerable.Range(0, 100)); ImmutableSortedTreeList <int> subList = list.GetRange(10, 80); List <int> subReference = reference.GetRange(10, 80); Assert.Equal(subReference, subList); // Verify that changes to the original list do not affect previous calls to GetRange int[] values = subList.ToArray(); list.Add(list[list.Count / 2]); reference.Insert((reference.Count / 2) + 1, reference[reference.Count / 2]); Assert.Equal(reference, list); Assert.Equal(values, subList); Assert.Equal(values, subReference); }
public void TestCopyTo() { var list = ImmutableSortedTreeList.CreateRange(comparer: null, items: Enumerable.Range(0, 100)).ToBuilder(); var reference = new List <int>(Enumerable.Range(0, 100)); int[] listArray = new int[list.Count * 2]; int[] referenceArray = new int[reference.Count * 2]; list.CopyTo(listArray); reference.CopyTo(referenceArray); Assert.Equal(referenceArray, listArray); list.CopyTo(listArray, 0); Assert.Equal(referenceArray, listArray); list.CopyTo(listArray, list.Count / 2); reference.CopyTo(referenceArray, reference.Count / 2); Assert.Equal(referenceArray, listArray); }