public void BasicInsert(T?[] items, T?item, int index, int repeat) { SegmentedList <T?> list = new SegmentedList <T?>(items); for (int i = 0; i < repeat; i++) { list.Insert(index, item); } Assert.True(list.Contains(item)); //"Expect it to contain the item." Assert.Equal(list.Count, items.Length + repeat); //"Expect to be the same." for (int i = 0; i < index; i++) { Assert.Equal(list[i], items[i]); //"Expect to be the same." } for (int i = index; i < index + repeat; i++) { Assert.Equal(list[i], item); //"Expect to be the same." } for (int i = index + repeat; i < list.Count; i++) { Assert.Equal(list[i], items[i - repeat]); //"Expect to be the same." } }
public void NonGenericIListBasicInsert(T?[] items, T?item, int index, int repeat) { SegmentedList <T?> list = new SegmentedList <T?>(items); IList _ilist = list; for (int i = 0; i < repeat; i++) { _ilist.Insert(index, item); } Assert.True(list.Contains(item)); //"Expected it to be true." Assert.Equal(list.Count, items.Length + repeat); //"Expected them to be equal." for (int i = 0; i < index; i++) { Assert.Equal(list[i], items[i]); //"Expected them to be equal." } for (int i = index; i < index + repeat; i++) { Assert.Equal((object?)list[i], item); //"Expected them to be equal." } for (int i = index + repeat; i < list.Count; i++) { Assert.Equal(list[i], items[i - repeat]); //"Expected them to be equal." } }
public void MultipleValues(T[] items, int times) { SegmentedList <T> list = new SegmentedList <T>(items); for (int i = 0; i < times; i++) { list.Add(items[items.Length / 2]); } for (int i = 0; i < times + 1; i++) { Assert.True(list.Contains(items[items.Length / 2])); //"Should contain item." list.Remove(items[items.Length / 2]); } Assert.False(list.Contains(items[items.Length / 2])); //"Should not contain item" }
public void NonExistingValues(T[] itemsX, T[] itemsY) { SegmentedList <T> list = new SegmentedList <T>(itemsX); for (int i = 0; i < itemsY.Length; i++) { Assert.False(list.Contains(itemsY[i])); //"Should not contain item" } }
public void BasicContains(T[] items) { SegmentedList <T> list = new SegmentedList <T>(items); for (int i = 0; i < items.Length; i++) { Assert.True(list.Contains(items[i])); //"Should contain item." } }
public void RemovedValues(T[] items) { SegmentedList <T> list = new SegmentedList <T>(items); for (int i = 0; i < items.Length; i++) { list.Remove(items[i]); Assert.False(list.Contains(items[i])); //"Should not contain item" } }
public void InsertRangeIEnumerable(T?[] itemsX, T?[] itemsY, int index, int repeat, Func <T?[], IEnumerable <T?> > constructIEnumerable) { SegmentedList <T?> list = new SegmentedList <T?>(constructIEnumerable(itemsX)); for (int i = 0; i < repeat; i++) { list.InsertRange(index, constructIEnumerable(itemsY)); } foreach (T?item in itemsY) { Assert.True(list.Contains(item)); //"Should contain the item." } Assert.Equal(list.Count, itemsX.Length + (itemsY.Length * repeat)); //"Should have the same result." for (int i = 0; i < index; i++) { Assert.Equal(list[i], itemsX[i]); //"Should have the same result." } for (int i = index; i < index + (itemsY.Length * repeat); i++) { Assert.Equal(list[i], itemsY[(i - index) % itemsY.Length]); //"Should have the same result." } for (int i = index + (itemsY.Length * repeat); i < list.Count; i++) { Assert.Equal(list[i], itemsX[i - (itemsY.Length * repeat)]); //"Should have the same result." } //InsertRange into itself list = new SegmentedList <T?>(constructIEnumerable(itemsX)); list.InsertRange(index, list); foreach (T?item in itemsX) { Assert.True(list.Contains(item)); //"Should contain the item." } Assert.Equal(list.Count, itemsX.Length + (itemsX.Length)); //"Should have the same result." for (int i = 0; i < index; i++) { Assert.Equal(list[i], itemsX[i]); //"Should have the same result." } for (int i = index; i < index + (itemsX.Length); i++) { Assert.Equal(list[i], itemsX[(i - index) % itemsX.Length]); //"Should have the same result." } for (int i = index + (itemsX.Length); i < list.Count; i++) { Assert.Equal(list[i], itemsX[i - (itemsX.Length)]); //"Should have the same result." } }
public void ContainsNullWhenReference(T?[] items, T?value) { if ((object?)value != null) { throw new ArgumentException("invalid argument passed to testcase"); } SegmentedList <T?> list = new SegmentedList <T?>(items); list.Add(value); Assert.True(list.Contains(value)); //"Should contain item." }
public void AddRemoveValues(T[] items) { SegmentedList <T> list = new SegmentedList <T>(items); for (int i = 0; i < items.Length; i++) { list.Add(items[i]); list.Remove(items[i]); list.Add(items[i]); Assert.True(list.Contains(items[i])); //"Should contain item." } }
/// <summary> /// Helper function to create an HashSet fulfilling the given specific parameters. The function will /// create an HashSet using the Comparer constructor and then add values /// to it until it is full. It will begin by adding the desired number of matching, /// followed by random (deterministic) elements until the desired count is reached. /// </summary> protected IEnumerable <T> CreateSegmentedHashSet(IEnumerable <T>?enumerableToMatchTo, int count, int numberOfMatchingElements) { SegmentedHashSet <T> set = new SegmentedHashSet <T>(GetIEqualityComparer()); int seed = 528; SegmentedList <T>?match = null; // Add Matching elements if (enumerableToMatchTo != null) { match = enumerableToMatchTo.ToSegmentedList(); for (int i = 0; i < numberOfMatchingElements; i++) { set.Add(match[i]); } } // Add elements to reach the desired count while (set.Count < count) { T toAdd = CreateT(seed++); while (set.Contains(toAdd) || (match != null && match.Contains(toAdd, GetIEqualityComparer()))) // Don't want any unexpectedly duplicate values { toAdd = CreateT(seed++); } set.Add(toAdd); } // Validate that the Enumerable fits the guidelines as expected Debug.Assert(set.Count == count); if (match != null) { int actualMatchingCount = 0; foreach (T lookingFor in match) { actualMatchingCount += set.Contains(lookingFor) ? 1 : 0; } Assert.Equal(numberOfMatchingElements, actualMatchingCount); } return(set); }