public void PlaceAfterWithUnknownTargetThrows()
{
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
DualLinkNode <int> unknownNode = new DualLinkNode <int>(TestObject, TestInt);
TestObject.PlaceAfter(testNode, unknownNode);
}
public void PlaceBeforeWithUnknownSourceThrows()
{
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
DualLinkNode <int> unknownNode = new DualLinkNode <int>(TestObject, TestInt);
TestObject.PlaceBefore(unknownNode, testNode);
}
private void VerifyTestObjectOrdering(int expectedNodes, List <IDualLinkNode <int> > nodeReference)
{
Assert.AreEqual(expectedNodes, TestObject.Count);
IDualLinkNode <int> currentNode = TestObject.First;
for (int i = 0; i < expectedNodes; i++)
{
if (i == 0)
{
Assert.IsNull(currentNode.Previous);
}
else
{
Assert.AreSame(nodeReference[i - 1], currentNode.Previous);
}
Assert.AreEqual(i, currentNode.Value);
if (i == expectedNodes - 1)
{
Assert.IsNull(currentNode.Next);
}
else
{
Assert.AreSame(nodeReference[i + 1], currentNode.Next);
}
currentNode = currentNode.Next;
}
}
public void AddBeforeReturnsNodeWithValue()
{
IDualLinkNode <int> first = TestObject.AddFirst(TestInt);
IDualLinkNode <int> actual = TestObject.AddBefore(first, TestInt);
Assert.AreEqual(TestInt, actual.Value);
}
public void RemoveReturnsNodeValue()
{
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
int actual = TestObject.Remove(testNode);
Assert.AreEqual(TestInt, actual);
}
public void AddAfterRemovedNodeThrows()
{
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.Remove(testNode);
TestObject.AddAfter(testNode, TestInt);
}
public void RemoveDecrementsCount()
{
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.Remove(testNode);
Assert.AreEqual(0, TestObject.Count);
}
public void PlaceAfterSetsFirst()
{
IDualLinkNode <int> last = TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.PlaceAfter(last, testNode);
Assert.AreSame(last, TestObject.First);
}
public void RemoveLastSetsNewLast()
{
IDualLinkNode <int> last = TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddLast(TestInt);
TestObject.Remove(testNode);
Assert.AreSame(last, TestObject.Last);
}
public void PlaceLastSetsNewFirst()
{
IDualLinkNode <int> newFirst = TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.PlaceLast(testNode);
Assert.AreSame(newFirst, TestObject.First);
}
public void PlaceLastSetsNodeAsLast()
{
TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.PlaceLast(testNode);
Assert.AreSame(testNode, TestObject.Last);
}
public void PlaceBeforeSetsLast()
{
IDualLinkNode <int> first = TestObject.AddFirst(TestInt);
IDualLinkNode <int> testNode = TestObject.AddLast(TestInt);
TestObject.PlaceBefore(first, testNode);
Assert.AreSame(first, TestObject.Last);
}
public void PlaceAfterRemovedNodeThrows()
{
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
IDualLinkNode <int> removedNode = TestObject.AddFirst(TestInt);
TestObject.Remove(removedNode);
TestObject.PlaceAfter(removedNode, testNode);
}
public void AddFirstAttachesBeforeCurrentFirst()
{
IDualLinkNode <int> original = TestObject.AddFirst(TestInt);
IDualLinkNode <int> actual = TestObject.AddFirst(TestInt);
Assert.AreSame(original, actual.Next);
Assert.AreSame(actual, original.Previous);
}
public void AddLastSetsFirstToFirstElement()
{
IDualLinkNode <int> original = TestObject.AddLast(TestInt);
IDualLinkNode <int> actual = TestObject.AddLast(TestInt);
Assert.AreSame(TestObject.First, original);
Assert.AreSame(TestObject.Last, actual);
}
public void RemoveFirstSetsNewFirst()
{
IDualLinkNode <int> first = TestObject.AddFirst(TestInt);
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.Remove(testNode);
Assert.AreSame(first, TestObject.First);
}
public void PlaceBefore(IDualLinkNode <TEntity> sourceNode, IDualLinkNode <TEntity> targetNode)
{
DualLinkNode <TEntity> source = FindNode(sourceNode);
DualLinkNode <TEntity> target = FindNode(targetNode);
if (source != target)
{
target.AttachBefore(source);
RealignEnds();
}
}
private void RealignEnds()
{
while (First?.Previous != null)
{
First = First.Previous;
}
while (Last?.Next != null)
{
Last = Last.Next;
}
}
public void PlaceLastMaintainsLinks()
{
IDualLinkNode <int> newFirst = TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddFirst(TestInt);
TestObject.PlaceLast(testNode);
Assert.IsNull(newFirst.Previous);
Assert.AreSame(testNode, newFirst.Next);
Assert.AreSame(newFirst, testNode.Previous);
Assert.IsNull(testNode.Next);
}
private DualLinkNode <TEntity> FindNode(IDualLinkNode <TEntity> suppliedNode)
{
if (suppliedNode != null)
{
if (!Nodes.TryGetValue(suppliedNode, out DualLinkNode <TEntity> foundNode))
{
throw new InvalidOperationException("Unknown node supplied");
}
return(foundNode);
}
return(null);
}
public void AddAfterIncrementsCount(int entities)
{
IDualLinkNode <int> startNode = TestObject.AddLast(TestInt);
for (int i = 1; i <= entities; i++)
{
TestObject.AddAfter(startNode, i);
Assert.AreEqual(i + 1, TestObject.Count);
}
Assert.AreEqual(entities + 1, TestObject.Count);
}
public void RemoveNullsNodeRelationships()
{
TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddLast(TestInt);
TestObject.AddLast(TestInt);
TestObject.Remove(testNode);
Assert.IsNull(testNode.Previous);
Assert.IsNull(testNode.Next);
}
public IDualLinkNode <TEntity> AddAfter(IDualLinkNode <TEntity> suppliedNode, TEntity entity)
{
DualLinkNode <TEntity> sourceNode = FindNode(suppliedNode);
DualLinkNode <TEntity> newNode = new DualLinkNode <TEntity>(this, entity);
if (sourceNode != null)
{
newNode.AttachAfter(sourceNode);
}
AddElement(newNode);
return(newNode);
}
private void AddElement(DualLinkNode <TEntity> node)
{
Nodes.Add(node, node);
if (First == null)
{
First = node;
}
if (Last == null)
{
Last = node;
}
RealignEnds();
}
public void PlaceAfterMaintainsLinks()
{
IDualLinkNode <int> first = TestObject.AddFirst(TestInt);
IDualLinkNode <int> last = TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddBefore(first, TestInt);
TestObject.PlaceAfter(first, testNode);
Assert.AreSame(testNode, first.Next);
Assert.AreSame(first, testNode.Previous);
Assert.AreSame(last, testNode.Next);
Assert.AreSame(testNode, last.Previous);
}
public void RemoveConnectsNulledRelationships()
{
IDualLinkNode <int> first = TestObject.AddLast(TestInt);
IDualLinkNode <int> testNode = TestObject.AddLast(TestInt);
IDualLinkNode <int> last = TestObject.AddLast(TestInt);
TestObject.Remove(testNode);
Assert.IsNull(first.Previous);
Assert.AreSame(last, first.Next);
Assert.AreSame(first, last.Previous);
Assert.IsNull(last.Next);
}
public void AddBeforePreservesLinking(int entities)
{
List <IDualLinkNode <int> > nodeReference = new List <IDualLinkNode <int> >();
IDualLinkNode <int> startNode = TestObject.AddFirst(entities);
for (int i = 0; i < entities; i++)
{
nodeReference.Add(
TestObject.AddBefore(startNode, i));
}
nodeReference.Add(startNode);
VerifyTestObjectOrdering(entities + 1, nodeReference);
}
/// <summary>
/// Fetches the node before another one (e.g. the node before the fourth is the third)
/// </summary>
/// <param name="node">the node that has a previous</param>
/// <returns></returns>
private IDualLinkNode <T> NodeBefore(IDualLinkNode <T> node)
{
if (FirstNode == null || node == FirstNode)
{
return(null);
}
var currentNode = FirstNode;
while (currentNode.Next != node)
{
currentNode = currentNode.Next;
}
return(currentNode);
}
public void AddAfterPreservesLinking(int entities)
{
List <IDualLinkNode <int> > nodeReference = new List <IDualLinkNode <int> >();
IDualLinkNode <int> startNode = TestObject.AddFirst(0);
for (int i = entities; i > 0; i--)
{
nodeReference.Add(
TestObject.AddAfter(startNode, i));
}
nodeReference.Add(startNode);
nodeReference.Reverse();
VerifyTestObjectOrdering(entities + 1, nodeReference);
}
public void TrimAfterSetsTrimNodeAsLast(int nodeCount, int trimIndex)
{
IDualLinkNode <int> trimNode = null;
for (int i = 0; i < nodeCount; i++)
{
IDualLinkNode <int> testNode = TestObject.AddLast(i);
if (i == trimIndex)
{
trimNode = testNode;
}
}
TestObject.TrimAfter(trimNode);
Assert.AreSame(trimNode, TestObject.Last);
}
