public void IndexOf_OrderIsCorrect( IndexOfMethod indexOfMethod, int count, bool frontToBackOrder ) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> withoutDuplicates = list.ToSegmentedList(); list.AddRange(list); IndexOfDelegate IndexOf = IndexOfDelegateFromType(indexOfMethod); Assert.All( Enumerable.Range(0, count), i => { if (frontToBackOrder) { Assert.Equal(i, IndexOf(list, withoutDuplicates[i])); } else { Assert.Equal(count + i, IndexOf(list, withoutDuplicates[i])); } } ); }
public void FindAll_VerifyDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); for (int i = 0; i < count / 2; i++) { list.Add(list[i]); } SegmentedList <T> beforeList = list.ToSegmentedList(); T? expectedItem = default(T); Predicate <T> EqualsDelegate = (value) => expectedItem == null ? value == null : expectedItem.Equals(value); //[] Verify FindAll returns the correct List with one item for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; SegmentedList <T> results = list.FindAll(EqualsDelegate); VerifyList(results, beforeList.Where((value) => EqualsDelegate(value)).ToSegmentedList()); } //[] Verify FindAll returns an List with all of the items if the predicate always returns true VerifyList(list.FindAll(_alwaysTrueDelegate), beforeList); //[] Verify FindAll returns an empty List if the match returns false on every item VerifyList(list.FindAll(_alwaysFalseDelegate), new SegmentedList <T>()); }
public void FindLastIndex_VerifyVanilla(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = delegate(T item) { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; //[] Verify FinIndex returns the correct index for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; index = list.FindLastIndex(EqualsDelegate); Assert.Equal(i, index); //"Err_282308ahid Expected FindLastIndex to return the same." } //[] Verify FindLastIndex returns 0 if the match returns true on every item int expected = count == 0 ? -1 : count - 1; index = list.FindLastIndex(_alwaysTrueDelegate); Assert.Equal(expected, index); //"Err_15198ajid Verify FindLastIndex returns 0 if the match returns true on every item" //[] Verify FindLastIndex returns -1 if the match returns false on every item index = list.FindLastIndex(_alwaysFalseDelegate); Assert.Equal(-1, index); //"Err_305981ajodd Verify FindLastIndex returns -1 if the match returns false on every item" }
public void LastIndexOf_int_OrderIsCorrectWithManyDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> withoutDuplicates = list.ToSegmentedList(); list.AddRange(list); list.AddRange(list); list.AddRange(list); Assert.All( Enumerable.Range(0, count), i => { Assert.All( Enumerable.Range(0, 4), j => { int expectedIndex = (j * count) + i; Assert.Equal( expectedIndex, list.LastIndexOf(withoutDuplicates[i], (count * (j + 1)) - 1) ); Assert.Equal( expectedIndex, list.LastIndexOf(withoutDuplicates[i], (count * (j + 1)) - 1, count) ); } ); } ); }
public void FindLastIndexInt_VerifyExceptions(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); Predicate <T> predicate = _alwaysTrueDelegate; //[] Verify Null match Assert.Throws <ArgumentNullException>(() => list.FindLastIndex(0, null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" /****************************************************************************** * index ******************************************************************************/ //[] Verify index=Int32.MinValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(int.MinValue, predicate)); //"Err_948ahid Expected index=Int32.MinValue to throw ArgumentOutOfRangeException" if (0 < list.Count) { //[] Verify index=-1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(-1, predicate)); //"Err_328ahuaw Expected index=-1 to throw ArgumentOutOfRangeException" } //[] Verify index=list.Count + 1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(list.Count + 1, predicate)); //"Err_488ajdi Expected index=list.Count + 1 to throw ArgumentOutOfRangeException" //[] Verify index=list.Count Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(list.Count, predicate)); //"Err_9689ajis Expected index=list.Count to throw ArgumentOutOfRangeException" //[] Verify index=Int32.MaxValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(int.MaxValue, predicate)); //"Err_238ajwisa Expected index=Int32.MaxValue to throw ArgumentOutOfRangeException" }
public void Reverse_RepeatedValues(int listLength, int index, int count) { SegmentedList <T> list = GenericListFactory(1); for (int i = 1; i < listLength; i++) { list.Add(list[0]); } SegmentedList <T> listBefore = list.ToSegmentedList(); list.Reverse(index, count); for (int i = 0; i < index; i++) { Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same." } int j = 0; for (int i = index; i < index + count; i++) { Assert.Equal(list[i], listBefore[index + count - (j + 1)]); //"Expect them to be the same." j++; } for (int i = index + count; i < listBefore.Count; i++) { Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same." } }
public void FindLast_VerifyDuplicates(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); T?foundItem; Predicate <T?> EqualsDelegate = (T? item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; if (0 < count) { list.Add(beforeList[0]); //[] Verify first item is duplicated expectedItem = beforeList[0]; foundItem = list.FindLast(EqualsDelegate); Assert.Equal(beforeList[0], foundItem); //"Err_2879072qaiadf Verify first item is duplicated FAILED\n" } if (1 < count) { list.Add(beforeList[1]); //[] Verify second item is duplicated expectedItem = beforeList[1]; foundItem = list.FindLast(EqualsDelegate); Assert.Equal(beforeList[1], foundItem); //"Err_4588ajdia Verify second item is duplicated FAILED\n" //[] Verify with match that matches more then one item foundItem = list.FindLast((T item) => { return(item != null && (item.Equals(beforeList[0]) || item.Equals(beforeList[1]))); }); Assert.Equal(beforeList[1], foundItem); //"Err_4489ajodoi Verify with match that matches more then one item FAILED\n" } }
public void Find_VerifyVanilla(int count) { SegmentedList <T?> list = GenericListFactory(count) !; SegmentedList <T?> beforeList = list.ToSegmentedList(); T?expectedItem = default(T); T?foundItem; Predicate <T?> EqualsDelegate = (T? item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; //[] Verify Find returns the correct index for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; foundItem = list.Find(EqualsDelegate); Assert.Equal(expectedItem, foundItem); //"Err_282308ahid Verifying value returned from Find FAILED\n" } //[] Verify Find returns the first item if the match returns true on every item foundItem = list.Find(_alwaysTrueDelegate); Assert.Equal(0 < count ? beforeList[0] : default(T), foundItem); //"Err_548ahid Verify Find returns the first item if the match returns true on every item FAILED\n" //[] Verify Find returns T.Default if the match returns false on every item foundItem = list.Find(_alwaysFalseDelegate); Assert.Equal(default(T), foundItem); //"Err_30848ahidi Verify Find returns T.Default if the match returns false on every item FAILED\n" //[] Verify with default(T) list.Add(default(T)); foundItem = list.Find((T? item) => { return(item == null ? default(T) == null : item.Equals(default(T))); }); Assert.Equal(default(T), foundItem); //"Err_541848ajodi Verify with default(T) FAILED\n" list.RemoveAt(list.Count - 1); }
public void FindLastIndexIntInt_VerifyDuplicates(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = (T item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; if (0 < count) { list.Add(beforeList[0]); //[] Verify first item is duplicated expectedItem = beforeList[0]; index = list.FindLastIndex(list.Count - 1, list.Count, EqualsDelegate); Assert.Equal(list.Count - 1, index); //"Err_3282iahid Verify first item is duplicated" } if (1 < count) { list.Add(beforeList[1]); //[] Verify second item is duplicated expectedItem = beforeList[1]; index = list.FindLastIndex(list.Count - 1, list.Count, EqualsDelegate); Assert.Equal(list.Count - 1, index); //"Err_29892adewiu Verify second item is duplicated" } }
public void AddRange_NullEnumerable_ThrowsArgumentNullException(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> listBeforeAdd = list.ToSegmentedList(); Assert.Throws <ArgumentNullException>(() => list.AddRange(null !)); Assert.Equal(listBeforeAdd, list); }
public void RemoveAll_AllElements(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int removedCount = list.RemoveAll((value) => { return(true); }); Assert.Equal(count, removedCount); Assert.Equal(0, list.Count); }
public void RemoveAll_DefaultElements(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); Predicate <T> EqualsDefaultElement = (value) => { return(default(T) == null ? value == null : default(T) !.Equals(value)); }; int expectedCount = beforeList.Count((value) => EqualsDefaultElement(value)); int removedCount = list.RemoveAll(EqualsDefaultElement); Assert.Equal(expectedCount, removedCount); }
public void FindIndexIntInt_VerifyExceptions(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); Predicate <T> predicate = delegate(T item) { return(true); }; //[] Verify Null match Assert.Throws <ArgumentNullException>(() => list.FindIndex(0, 0, null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" /****************************************************************************** * index ******************************************************************************/ //[] Verify index=Int32.MinValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(int.MinValue, 0, predicate)); //"Err_948ahid Expected index=Int32.MinValue to throw ArgumentOutOfRangeException" //[] Verify index=-1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(-1, 0, predicate)); //"Err_328ahuaw Expected index=-1 to throw ArgumentOutOfRangeException" //[] Verify index=list.Count + 1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(list.Count + 1, 0, predicate)); //"Err_488ajdi Expected index=list.Count + 1 to throw ArgumentOutOfRangeException" //[] Verify index=list.Count Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(list.Count, 1, predicate)); //"Err_9689ajis Expected index=list.Count to throw ArgumentOutOfRangeException" //[] Verify index=Int32.MaxValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(int.MaxValue, 0, predicate)); //"Err_238ajwisa Expected index=Int32.MaxValue to throw ArgumentOutOfRangeException" /****************************************************************************** * count ******************************************************************************/ //[] Verify count=Int32.MinValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(0, int.MinValue, predicate)); //Err_948ahid Expected count=Int32.MinValue to throw ArgumentOutOfRangeException" //[] Verify count=-1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(0, -1, predicate)); //"Err_328ahuaw Expected count=-1 to throw ArgumentOutOfRangeException" //[] Verify count=list.Count + 1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(0, list.Count + 1, predicate)); //"Err_488ajdi Expected count=list.Count + 1 to throw ArgumentOutOfRangeException" //[] Verify count=Int32.MaxValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(0, int.MaxValue, predicate)); //"Err_238ajwisa Expected count=Int32.MaxValue to throw ArgumentOutOfRangeException" /****************************************************************************** * index and count ******************************************************************************/ if (0 < count) { //[] Verify index=1 count=list.Length Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(1, count, predicate)); //"Err_018188avbiw Expected index=1 count=list.Length to throw ArgumentOutOfRangeException" //[] Verify index=0 count=list.Length + 1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex(0, count + 1, predicate)); //"Err_6848ajiodxbz Expected index=0 count=list.Length + 1 to throw ArgumentOutOfRangeException" } }
public void IndexOf_NoDuplicates(IndexOfMethod indexOfMethod, int count, bool frontToBackOrder) { _ = frontToBackOrder; SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> expectedList = list.ToSegmentedList(); IndexOfDelegate IndexOf = IndexOfDelegateFromType(indexOfMethod); Assert.All(Enumerable.Range(0, count), i => { Assert.Equal(i, IndexOf(list, expectedList[i])); }); }
public void Reverse(int listLength) { SegmentedList <T> list = GenericListFactory(listLength); SegmentedList <T> listBefore = list.ToSegmentedList(); list.Reverse(); for (int i = 0; i < listBefore.Count; i++) { Assert.Equal(list[i], listBefore[listBefore.Count - (i + 1)]); //"Expect them to be the same." } }
public void FindIndexInt_VerifyVanilla(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = delegate(T item) { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; //[] Verify FinIndex returns the correct index for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; index = list.FindIndex(0, EqualsDelegate); Assert.Equal(i, index); //"Err_282308ahid Expected FindIndex to return the same" } //[] Verify FindIndex returns 0 if the match returns true on every item int expected = count == 0 ? -1 : 0; index = list.FindIndex(0, delegate(T item) { return(true); }); Assert.Equal(expected, index); //"Err_15198ajid Verify FindIndex returns 0 if the match returns true on every item " //[] Verify FindIndex returns -1 if the match returns false on every item index = list.FindIndex(0, delegate(T item) { return(false); }); Assert.Equal(-1, index); //"Err_305981ajodd Verify FindIndex returns -1 if the match returns false on every item" //[] Verify FindIndex returns -1 if the index == count index = list.FindIndex(count, delegate(T item) { return(true); }); Assert.Equal(-1, index); //"Err_4858ajodoa Verify FindIndex returns -1 if the index == count" if (0 < count) { //[] Verify NEG FindIndex uses the index expectedItem = beforeList[0]; index = list.FindIndex(1, EqualsDelegate); Assert.Equal(-1, index); //"Err_548797ahjid Verify NEG FindIndex uses the index" } if (1 < count) { //[] Verify POS FindIndex uses the index LOWER expectedItem = beforeList[1]; index = list.FindIndex(1, EqualsDelegate); Assert.Equal(1, index); //"Err_68797ahid Verify POS FindIndex uses the index LOWER" //[] Verify POS FindIndex uses the index UPPER expectedItem = beforeList[count - 1]; index = list.FindIndex(1, EqualsDelegate); Assert.Equal(count - 1, index); //"Err_51488ajod Verify POS FindIndex uses the index UPPER" } }
public void ConvertAll() { var list = new SegmentedList <int>(new int[] { 1, 2, 3 }); var before = list.ToSegmentedList(); var after = list.ConvertAll((i) => { return(10 * i); }); Assert.Equal(before.Count, list.Count); Assert.Equal(before.Count, after.Count); for (int i = 0; i < list.Count; i++) { Assert.Equal(before[i], list[i]); Assert.Equal(before[i] * 10, after[i]); } }
public void Remove_Range(int listLength, int index, int count) { SegmentedList <T> list = GenericListFactory(listLength); SegmentedList <T> beforeList = list.ToSegmentedList(); list.RemoveRange(index, count); Assert.Equal(list.Count, listLength - count); //"Expected them to be the same." for (int i = 0; i < index; i++) { Assert.Equal(list[i], beforeList[i]); //"Expected them to be the same." } for (int i = index; i < count - (index + count); i++) { Assert.Equal(list[i], beforeList[i + count]); //"Expected them to be the same." } }
public void BinarySearch_ForEveryItemWithDuplicates(int count) { if (count > 0) { SegmentedList <T> list = GenericListFactory(count); list.Add(list[0]); list.Sort(); SegmentedList <T> beforeList = list.ToSegmentedList(); Assert.All(Enumerable.Range(0, list.Count), index => { Assert.True(list.BinarySearch(beforeList[index]) >= 0); Assert.True(list.BinarySearch(beforeList[index], GetIComparer()) >= 0); Assert.Equal(beforeList[index], list[index]); }); } }
public void FindVerifyExceptions(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); //[] Verify Null match Find Assert.Throws <ArgumentNullException>(() => list.Find(null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" //[] Verify Null match FindLast Assert.Throws <ArgumentNullException>(() => list.FindLast(null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" //[] Verify Null match FindLastIndex Assert.Throws <ArgumentNullException>(() => list.FindLastIndex(null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" //[] Verify Null match FindAll Assert.Throws <ArgumentNullException>(() => list.FindAll(null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" }
public void AddRange(EnumerableType enumerableType, int listLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements) { SegmentedList <T> list = GenericListFactory(listLength); SegmentedList <T> listBeforeAdd = list.ToSegmentedList(); IEnumerable <T> enumerable = CreateEnumerable(enumerableType, list, enumerableLength, numberOfMatchingElements, numberOfDuplicateElements); list.AddRange(enumerable); // Check that the first section of the List is unchanged Assert.All(Enumerable.Range(0, listLength), index => { Assert.Equal(listBeforeAdd[index], list[index]); }); // Check that the added elements are correct Assert.All(Enumerable.Range(0, enumerableLength), index => { Assert.Equal(enumerable.ElementAt(index), list[index + listLength]); }); }
public void BinarySearch_ForEveryItemWithoutDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); foreach (T item in list) { while (list.Count((value) => value.Equals(item)) > 1) { list.Remove(item); } } list.Sort(); SegmentedList <T> beforeList = list.ToSegmentedList(); Assert.All(Enumerable.Range(0, list.Count), index => { Assert.Equal(index, list.BinarySearch(beforeList[index])); Assert.Equal(index, list.BinarySearch(beforeList[index], GetIComparer())); Assert.Equal(beforeList[index], list[index]); }); }
public void FindIndexIntInt_VerifyDuplicates(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = delegate(T item) { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; if (0 < count) { list.Add(beforeList[0]); //[] Verify first item is duplicated expectedItem = beforeList[0]; index = list.FindIndex(0, list.Count, EqualsDelegate); Assert.Equal(0, index); //"Err_3282iahid Verify first item is duplicated" //[] Verify first item is duplicated and index=1 expectedItem = beforeList[0]; index = list.FindIndex(1, list.Count - 1, EqualsDelegate); Assert.Equal(count, index); //"Err_8588ahidi Verify first item is duplicated and index=1" } if (1 < count) { list.Add(beforeList[1]); //[] Verify second item is duplicated expectedItem = beforeList[1]; index = list.FindIndex(0, list.Count, EqualsDelegate); Assert.Equal(1, index); //"Err_29892adewiu Verify second item is duplicated" //[] Verify second item is duplicated and index=2 expectedItem = beforeList[1]; index = list.FindIndex(2, list.Count - 2, EqualsDelegate); Assert.Equal(count + 1, index); //"Err_1580ahisdf Verify second item is duplicated and index=2" } }
public void FindLastIndexIntInt_VerifyVanilla(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = (T item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; for (int i = 0; i < count; ++i) { list.Add(beforeList[i]); } //[] Verify FinIndex returns the correct index for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; index = list.FindLastIndex(count - 1, count, EqualsDelegate); Assert.Equal(i, index); //"Err_282308ahid Expected FindLastIndex to be the same." } //[] Verify FindLastIndex returns 0 if the match returns true on every item int expected = count == 0 ? -1 : count - 1; index = list.FindLastIndex(count - 1, count, _alwaysTrueDelegate); Assert.Equal(expected, index); //"Err_15198ajid Verify FindLastIndex returns 0 if the match returns true on every item" //[] Verify FindLastIndex returns -1 if the match returns false on every item index = list.FindLastIndex(count - 1, count, _alwaysFalseDelegate); Assert.Equal(-1, index); //"Err_305981ajodd Verify FindLastIndex returns -1 if the match returns false on every item" if (0 < count) { //[] Verify FindLastIndex returns -1 if the index == 0 index = list.FindLastIndex(0, 0, _alwaysTrueDelegate); Assert.Equal(-1, index); //"Err_298298ahdi Verify FindLastIndex returns -1 if the index=0" //[] Verify NEG FindLastIndex uses the count expectedItem = beforeList[0]; index = list.FindLastIndex(count - 1, count - 1, EqualsDelegate); Assert.Equal(-1, index); //"Err_7894ahoid Verify NEG FindLastIndex uses the count" } if (1 < count) { //[] Verify NEG FindLastIndex uses the index expectedItem = beforeList[count - 1]; index = list.FindLastIndex(count - 2, count - 1, EqualsDelegate); Assert.Equal(-1, index); //"Err_548797ahjid Verify NEG FindLastIndex uses the index" //[] Verify POS FindLastIndex uses the index expectedItem = beforeList[count - 2]; index = list.FindLastIndex(count - 2, count - 1, EqualsDelegate); Assert.Equal(count - 2, index); //"Err_68797ahid Verify POS FindLastIndex uses the index" //[] Verify POS FindLastIndex uses the count expectedItem = beforeList[count - 2]; index = list.FindLastIndex(count - 1, count - 1, EqualsDelegate); Assert.Equal(count - 2, index); //"Err_28278ahdii Verify POS FindLastIndex uses the count" //[] Verify NEG FindLastIndex uses the index and count LOWER expectedItem = beforeList[0]; index = list.FindLastIndex(count - 2, count - 2, EqualsDelegate); Assert.Equal(-1, index); //"Err_384984ahjiod Verify NEG FindLastIndex uses the index and count LOWER" //[] Verify NEG FindLastIndex uses the index and count UPPER expectedItem = beforeList[count - 1]; index = list.FindLastIndex(count - 2, count - 2, EqualsDelegate); Assert.Equal(-1, index); //"Err_1489haidid Verify NEG FindLastIndex uses the index and count UPPER" //[] Verify POS FindLastIndex uses the index and count LOWER expectedItem = beforeList[1]; index = list.FindLastIndex(count - 2, count - 2, EqualsDelegate); Assert.Equal(1, index); //"Err_604890ahjid Verify POS FindLastIndex uses the index and count LOWER" //[] Verify POS FindLastIndex uses the index and count UPPER expectedItem = beforeList[count - 2]; index = list.FindLastIndex(count - 2, count - 2, EqualsDelegate); Assert.Equal(count - 2, index); //"Err_66844ahidd Verify POS FindLastIndex uses the index and count UPPER" } }