Added ListSegment class which is analogous to StringSegment and ArraySegment, but for IList<T>
git-svn-id: file:///srv/devel/repo-conversion/nusu@336 d2e56fa2-650e-0410-a79f-9358c0239efd
This commit is contained in:
Markus Ewald
parent
207a17712e
commit
c7dd57f59f
5 changed files with 907 additions and 397 deletions
257
Source/Collections/ListSegment.Test.cs
Normal file
257
Source/Collections/ListSegment.Test.cs
Normal file
|
|
@ -0,0 +1,257 @@
|
|||
#region CPL License
|
||||
/*
|
||||
Nuclex Framework
|
||||
Copyright (C) 2002-2017 Nuclex Development Labs
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the IBM Common Public License as
|
||||
published by the IBM Corporation; either version 1.0 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
IBM Common Public License for more details.
|
||||
|
||||
You should have received a copy of the IBM Common Public
|
||||
License along with this library
|
||||
*/
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
|
||||
#if UNITTEST
|
||||
|
||||
using NUnit.Framework;
|
||||
|
||||
namespace Nuclex.Support.Collections {
|
||||
|
||||
/// <summary>Unit Test for the list segment class</summary>
|
||||
[TestFixture]
|
||||
internal class ListSegmentTest {
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the default constructor of the ListSegment class throws the
|
||||
/// right exception when being passed 'null' instead of a list
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void SimpleConstructorThrowsWhenListIsNull() {
|
||||
Assert.Throws<ArgumentNullException>(
|
||||
delegate() { new ListSegment<int>(null); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the simple constructor of the ListSegment class accepts
|
||||
/// an empty list
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void SimpleConstructorAcceptsEmptyList() {
|
||||
new ListSegment<int>(new List<int>());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the full constructor of the ListSegment class throws the
|
||||
/// right exception when being passed 'null' instead of a string
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void ConstructorThrowsWhenListIsNull() {
|
||||
Assert.Throws<ArgumentNullException>(
|
||||
delegate() { new ListSegment<int>(null, 0, 0); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the full constructor of the ListSegment class accepts
|
||||
/// an empty string
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void ConstructorAcceptsEmptyList() {
|
||||
new ListSegment<int>(new List<int>(), 0, 0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the full constructor of the ListSegment class throws the
|
||||
/// right exception when being passed an invalid start offset
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void ConstructorThrowsOnInvalidOffset() {
|
||||
Assert.Throws<ArgumentOutOfRangeException>(
|
||||
delegate() { new ListSegment<int>(new List<int>(), -1, 0); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the full constructor of the ListSegment class throws the
|
||||
/// right exception when being passed an invalid element count
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void ConstructorThrowsOnInvalidCount() {
|
||||
Assert.Throws<ArgumentOutOfRangeException>(
|
||||
delegate() { new ListSegment<int>(new List<int>(), 0, -1); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether the full constructor of the ListSegment class throws the
|
||||
/// right exception when being passed a string length that's too large
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void ConstructorThrowsOnListOverrun() {
|
||||
var testList = new List<int>(capacity: 5) { 1, 2, 3, 4, 5 };
|
||||
Assert.Throws<ArgumentException>(
|
||||
delegate() { new ListSegment<int>(testList, 3, 3); }
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the 'Text' property works as expected</summary>
|
||||
[Test]
|
||||
public void ListPropertyStoresOriginalList() {
|
||||
var testList = new List<int>(capacity: 5) { 1, 2, 3, 4, 5 };
|
||||
ListSegment<int> testSegment = new ListSegment<int>(testList, 1, 3);
|
||||
Assert.AreSame(testList, testSegment.List);
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the 'Offset' property works as expected</summary>
|
||||
[Test]
|
||||
public void OffsetPropertyIsStored() {
|
||||
var testList = new List<int>(capacity: 5) { 1, 2, 3, 4, 5 };
|
||||
ListSegment<int> testSegment = new ListSegment<int>(testList, 1, 3);
|
||||
Assert.AreEqual(1, testSegment.Offset);
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the 'Count' property works as expected</summary>
|
||||
[Test]
|
||||
public void CountPropertyIsStored() {
|
||||
var testList = new List<int>(capacity: 5) { 1, 2, 3, 4, 5 };
|
||||
ListSegment<int> testSegment = new ListSegment<int>(testList, 1, 3);
|
||||
Assert.AreEqual(3, testSegment.Count);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether two differing instances produce different hash codes
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void DifferentInstancesHaveDifferentHashCodes_Usually() {
|
||||
var forwardCountSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
var reverseCountSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 9, 8, 7, 6, 5, 4, 3, 2, 1 }, 1, 8
|
||||
);
|
||||
|
||||
Assert.AreNotEqual(
|
||||
forwardCountSegment.GetHashCode(), reverseCountSegment.GetHashCode()
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether two equivalent instances produce an identical hash code
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void EquivalentInstancesHaveSameHashcode() {
|
||||
var testSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
var identicalSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
|
||||
Assert.AreEqual(
|
||||
testSegment.GetHashCode(), identicalSegment.GetHashCode()
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>Tests the equals method performing a comparison against null</summary>
|
||||
[Test]
|
||||
public void EqualsAgainstNullIsAlwaysFalse() {
|
||||
var testList = new List<int>(capacity: 5) { 1, 2, 3, 4, 5 };
|
||||
ListSegment<int> testSegment = new ListSegment<int>(testList, 1, 3);
|
||||
|
||||
Assert.IsFalse(
|
||||
testSegment.Equals(null)
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>Tests the equality operator with differing instances</summary>
|
||||
[Test]
|
||||
public void DifferingInstancesAreNotEqual() {
|
||||
var forwardCountSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
var reverseCountSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 9, 8, 7, 6, 5, 4, 3, 2, 1 }, 1, 8
|
||||
);
|
||||
|
||||
Assert.IsFalse(forwardCountSegment == reverseCountSegment);
|
||||
}
|
||||
|
||||
/// <summary>Tests the equality operator with equivalent instances</summary>
|
||||
[Test]
|
||||
public void EquivalentInstancesAreEqual() {
|
||||
var testSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
var identicalSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
|
||||
Assert.IsTrue(testSegment == identicalSegment);
|
||||
}
|
||||
|
||||
/// <summary>Tests the inequality operator with differing instances</summary>
|
||||
[Test]
|
||||
public void DifferingInstancesAreUnequal() {
|
||||
var forwardCountSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
var reverseCountSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 9, 8, 7, 6, 5, 4, 3, 2, 1 }, 1, 8
|
||||
);
|
||||
|
||||
Assert.IsTrue(forwardCountSegment != reverseCountSegment);
|
||||
}
|
||||
|
||||
/// <summary>Tests the inequality operator with equivalent instances</summary>
|
||||
[Test]
|
||||
public void EquivalentInstancesAreNotUnequal() {
|
||||
var testSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
var identicalSegment = new ListSegment<int>(
|
||||
new List<int>(capacity: 9) { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 7
|
||||
);
|
||||
|
||||
Assert.IsFalse(testSegment != identicalSegment);
|
||||
}
|
||||
|
||||
/// <summary>Tests the ToString() method of the string segment</summary>
|
||||
[Test]
|
||||
public void TestToString() {
|
||||
var testList = new List<int>(capacity: 6) { 1, 2, 3, 4, 5, 6 };
|
||||
ListSegment<int> testSegment = new ListSegment<int>(testList, 2, 2);
|
||||
|
||||
string stringRepresentation = testSegment.ToString();
|
||||
StringAssert.Contains("3, 4", stringRepresentation);
|
||||
StringAssert.DoesNotContain("2", stringRepresentation);
|
||||
StringAssert.DoesNotContain("5", stringRepresentation);
|
||||
}
|
||||
|
||||
/// <summary>Tests whether the 'Text' property works as expected</summary>
|
||||
[Test]
|
||||
public void ToListReturnsSubset() {
|
||||
var testList = new List<int>(capacity: 5) { 1, 2, 3, 4, 5 };
|
||||
ListSegment<int> testSegment = new ListSegment<int>(testList, 1, 3);
|
||||
CollectionAssert.AreEqual(
|
||||
new List<int>(capacity: 3) { 2, 3, 4 },
|
||||
testSegment.ToList()
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} // namespace Nuclex.Support.Collections
|
||||
|
||||
#endif // UNITTEST
|
||||
Loading…
Add table
Add a link
Reference in a new issue