public void Add_ElementByIndexZero_ShouldBeAbleToRetriveIt()
{
var sll = new SimpleLinkedList<bool> { { true, 0 } };
Assert.AreEqual(1, sll.Count());
Assert.AreEqual(true, sll.First());
}
private static string DescribeDestinations(SimpleLinkedList<Node> destinations)
{
if (destinations == null || destinations.Count == 0)
{
return "nowhere";
}
StringBuilder sb = new StringBuilder();
sb.Append("to ");
sb.Append(destinations.Count);
sb.Append(" nodes:");
List<Node> nodes = destinations.PeekAll();
foreach (Node node in nodes)
{
sb.Append(Environment.NewLine);
sb.Append(" *");
sb.Append(node.NodeGroup.GroupName);
sb.Append(" ");
sb.Append(node.Host);
sb.Append(":");
sb.Append(node.Port);
}
return sb.ToString();
}
public void Add_SingleElementToList_ShouldBeAbleToRetriveIt()
{
var sll = new SimpleLinkedList<bool> {true};
Assert.AreEqual(1, sll.Count());
Assert.AreEqual(true, sll.First());
}
public void Remove_SingleElement_ShouldWork()
{
var sll = new SimpleLinkedList<bool> { true };
sll.Remove(0);
Assert.AreEqual(0, sll.Count());
}
public void Reverse(int length)
{
var values = Enumerable.Range(1, length).ToArray();
var list = new SimpleLinkedList<int>(values);
var reversed = list.Reverse();
Assert.That(reversed, Is.EqualTo(values.Reverse()));
}
public void AddLastMethod_IncrementsLengthOfList()
{
SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
linkedList.AddLast("asdf");
Assert.True(linkedList.Count == 1);
}
public void From_enumerable()
{
var list = new SimpleLinkedList<int>(new[] { 11, 7, 5, 3, 2 });
Assert.That(list.Value, Is.EqualTo(11));
Assert.That(list.Next.Value, Is.EqualTo(7));
Assert.That(list.Next.Next.Value, Is.EqualTo(5));
Assert.That(list.Next.Next.Next.Value, Is.EqualTo(3));
Assert.That(list.Next.Next.Next.Next.Value, Is.EqualTo(2));
}
public void AddFirstMethod_AddsNewItemAtTheHeadOfList()
{
SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
linkedList.AddFirst("new Item 1");
Assert.ReferenceEquals(linkedList.First, "new Item 1");
Assert.Equal("new Item 1", linkedList.First.Item);
}
public void Add_ThreeElementsToList_ShouldBeAbleToRetriveIt()
{
var sll = new SimpleLinkedList<bool> {true, true, false};
Assert.AreEqual(3, sll.Count());
Assert.AreEqual(true, sll.First());
Assert.AreEqual(true, sll.Skip(1).First());
Assert.AreEqual(false, sll.Last());
}
public void CopyToWithNullArray()
{
SimpleLinkedList<int> list = new SimpleLinkedList<int>();
int[] array = new int[0];
list.Add(3);
list.Add(5);
list.Add(7);
list.CopyTo(array, 0);
}
public void CopyToWithLessSpaceInTheArray()
{
SimpleLinkedList<int> list = new SimpleLinkedList<int>();
int[] array = new int[3];
list.Add(3);
list.Add(5);
list.Add(7);
list.CopyTo(array, 2);
}
public void CopyToWithNegativeIndex()
{
SimpleLinkedList<int> list = new SimpleLinkedList<int>();
int[] array = new int[3];
list.Add(3);
list.Add(5);
list.Add(7);
list.CopyTo(array, -2);
}
public void Contains()
{
SimpleLinkedList<int> list = new SimpleLinkedList<int>();
list.Add(3);
list.Add(5);
list.Add(7);
bool isTrue = list.Contains(7);
Assert.AreEqual(true, isTrue);
}
public void ClearList()
{
SimpleLinkedList<int> list = new SimpleLinkedList<int>();
list.Add(3);
list.Add(5);
list.Add(7);
list.Clear();
list.ShouldBeEmpty();
}
public void AddFirstMethod_IncrementsLengthOfList()
{
SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
int expectedCount = 0;
linkedList.AddFirst("asdf"); expectedCount++;
Assert.Equal(expectedCount, linkedList.Count);
}
public void Add_ElementByIndex_ShouldBeAbleToRetriveIt()
{
var sll = new SimpleLinkedList<bool> {true, true, true, {false, 1}};
Assert.AreEqual(4, sll.Count());
Assert.AreEqual(true, sll.First());
Assert.AreEqual(false, sll.Skip(1).First());
Assert.AreEqual(true, sll.Skip(2).First());
Assert.AreEqual(true, sll.Last());
}
public void AddLastMethod_AddsNewItemAtTheTailOfList()
{
SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
linkedList.AddLast("new Item 1");
linkedList.AddLast("new Item 2");
Assert.ReferenceEquals(linkedList.Last, "new Item 2");
Assert.True(linkedList.Last.Item == "new Item 2");
}
public void AddFirstMethod_SetsThe_LinkProperty_OfTheCurrentHeadToThePreviousHeadOfTheList()
{
SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
linkedList.AddFirst("new Item 1");
linkedList.AddFirst("new Item 2");
Assert.ReferenceEquals(linkedList.First.Link, "new Item 1");
Assert.Equal("new Item 1", linkedList.First.Link.Item);
}
public void Remove_SecondElement_ShouldWork()
{
var sll = new SimpleLinkedList<bool> { true, false, true, true, true };
sll.Remove(1);
Assert.AreEqual(4, sll.Count());
Assert.AreEqual(true, sll.First());
Assert.AreEqual(true, sll.Skip(1).First());
Assert.AreEqual(true, sll.Skip(2).First());
Assert.AreEqual(true, sll.Last());
}
public void AddLastMethod_SetsThe_LinkProperty_OfThePreviousTailToTheCurrentTailOfTheList()
{
SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
linkedList.AddLast("new Item 1");
LinkedListNode<string> previousTail = linkedList.Last;
linkedList.AddLast("new Item 2");
LinkedListNode<string> currentTail = linkedList.Last;
Assert.ReferenceEquals(previousTail.Link, currentTail);
Assert.Equal("new Item 2", previousTail.Link.Item);
}
public void TestHeadAssignmenet_RemoveFirstElementAndAddToFirstPosition_ElementShouldBeAssignedToSecondPosition()
{
var sll = new SimpleLinkedList<int> { 1, 2, 3, 4, 5 };
sll.Remove(0);
sll.Add(6, 0);
Assert.AreEqual(5, sll.Count());
Assert.AreEqual(6, sll.First());
Assert.AreEqual(2, sll.Skip(1).First());
Assert.AreEqual(3, sll.Skip(2).First());
Assert.AreEqual(4, sll.Skip(3).First());
Assert.AreEqual(5, sll.Skip(4).First());
Assert.AreEqual(5, sll.Last());
}
static void Main(string[] args)
{
SimpleLinkedList<int> list = new SimpleLinkedList<int>();
list.Add(1);
list.Add(2);
list.Add(3);
list.Add(4);
list.Add(5);
string listStr = list.ToString();
Console.WriteLine(listStr);
/* Remove an item */
list.Remove(5);
listStr = list.ToString();
Console.WriteLine(listStr);
}
internal static void WriteDebugInfo(RelayMessage message, SimpleLinkedList<Node> destinations)
{
if (WriteMessageTrace && message != null)
{
StringBuilder debugString = new StringBuilder();
StackTrace stack = null;
if (WriteCallingMethod)
{
stack = new StackTrace(2,true);
}
debugString.Append("Relay Forwarding: ");
debugString.Append(message.ToString());
debugString.Append(Environment.NewLine);
debugString.Append(" sending " + DescribeDestinations(destinations));
if (stack != null)
{
debugString.Append(Environment.NewLine);
debugString.Append(" called ");
debugString.Append(stack.ToString());
}
_messageTracer.WriteLogMessage(message.MessageType,message.TypeId,debugString.ToString());
}
}
public void Two_item_list_second_value()
{
var list = new SimpleLinkedList <int>(2).Add(1);
Assert.That(list.Next.Value, Is.EqualTo(1));
}
public void Two_item_list_second_value()
{
var list = new SimpleLinkedList<int>(2).Add(1);
Assert.That(list.Next.Value, Is.EqualTo(1));
}
public void Single_item_list_has_no_next_item()
{
var list = new SimpleLinkedList <int>(1);
Assert.That(list.Next, Is.Null);
}
public static T[] ToArray(this SimpleLinkedList <T> where T : IComparable simpleLinkedList)
public void Reset()
{
bof = true;
node = head;
}
public void Single_item_list_value()
{
var list = new SimpleLinkedList <int>(1);
Assert.That(list.Value, Is.EqualTo(1));
}
public SimpleLinkedList <T> Reverse(SimpleLinkedList <T> previous = null)
{
var newThis = new SimpleLinkedList <T>(Value, previous);
return(Next == null ? newThis : Next.Reverse(newThis));
}
internal SimpleLinkedList<Node> GetNodesForMessage(RelayMessage message)
{
SimpleLinkedList<Node> nodes = null;
if (message == null || message.RelayTTL < 1 || NodeGroups == null)
{
return new SimpleLinkedList<Node>();
}
const bool useLegacySerialization = true;
//commands that, from out of system, route to all groups
if (message.IsGroupBroadcastMessage)
{
message.PrepareMessageToBeSent(useLegacySerialization);
if (MyNodeGroup == null)//out of system: all groups
{
nodes = new SimpleLinkedList<Node>();
for (int groupIndex = 0; groupIndex < this.NodeGroups.Count; groupIndex++)
{
nodes.Push(NodeGroups[groupIndex].GetNodesForMessage(message));
}
}
else//In system: my group
{
nodes = MyNodeGroup.MyCluster.GetNodesForMessage(message);
}
}
else
{
//Commands that always route to a single group
NodeGroup group = GetNodeGroup(message.TypeId);
if (group != null)
{
message.PrepareMessageToBeSent(group.GroupDefinition.LegacySerialization);
nodes = group.GetNodesForMessage(message);
}
else
{
message.PrepareMessageToBeSent(useLegacySerialization);
if (_log.IsErrorEnabled)
_log.ErrorFormat("No group found for {0}", message);
nodes = new SimpleLinkedList<Node>();
}
}
if (nodes == null)
{
nodes = new SimpleLinkedList<Node>();
}
// If no nodes are returned, we predict that the caller
// will drop the message. Therefore we call the notification delegate.
// This is admittedly a kludgy solution, but the only one
// available without changing this method's signature.
// A better solution should be adopted. [tchow 01/29/2008]
if (nodes.Count == 0)
{
Forwarder.RaiseMessageDropped(message);
}
return nodes;
}
/// <summary>
/// Splits messages into various lists of in and out message destined for different nodes.
/// </summary>
/// <param name="messages"></param>
/// <returns></returns>
internal NodeWithMessagesCollection DistributeMessages(IList<RelayMessage> messages)
{
NodeWithMessagesCollection distribution = new NodeWithMessagesCollection();
RelayMessage message;
Node node;
for(int i = 0 ; i < messages.Count ; i++)
{
if (messages[i] != null)
{
message = messages[i];
RelayMessage interZoneMessage = null;
SimpleLinkedList<Node> nodesForMessage = GetNodesForMessage(message);
SimpleLinkedList<Node> nodesForInterZoneMessage = null;
if (nodesForMessage.Count > 0)
{
message.AddressHistory.Add(MyIpAddress);
}
message.RelayTTL--;
#region Identify InterZone Messages
if(message.IsTwoWayMessage == false)
{
message.ResultOutcome = RelayOutcome.Queued; //will be queued, if sync will not get overwritten
// Identify nodes in foreign zones
int nodeCount = nodesForMessage.Count;
for (int nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++)
{
nodesForMessage.Pop(out node);
if (_myNodeDefinition != null && _myNodeDefinition.Zone != node.NodeDefinition.Zone)
{
// Message needs to cross Zone bounderies
if (interZoneMessage == null)
{
interZoneMessage = RelayMessage.CreateInterZoneMessageFrom(message);
nodesForInterZoneMessage = new SimpleLinkedList<Node>();
}
nodesForInterZoneMessage.Push(node);
}
else
{
nodesForMessage.Push(node);
}
}
}
#endregion
if (nodesForMessage.Count > 0)
{
DebugWriter.WriteDebugInfo(message, nodesForMessage);
distribution.Add(message, nodesForMessage);
}
if (nodesForInterZoneMessage != null && nodesForInterZoneMessage.Count > 0)
{
DebugWriter.WriteDebugInfo(interZoneMessage, nodesForInterZoneMessage);
distribution.Add(interZoneMessage, nodesForInterZoneMessage);
}
}
}
return distribution;
}
public void Single_item_list_has_no_next_item()
{
var list = new SimpleLinkedList<int>(1);
Assert.That(list.Next, Is.Null);
}
public Enumor(SimpleLinkedList <T> head)
{
this.head = head;
Reset();
}
public void DefaultConstructor_SetsLengthToZero()
{
SimpleLinkedList <string> linkedList = new SimpleLinkedList <String>();
Assert.Equal(0, linkedList.Count);
}
public void Single_item_list_value()
{
var list = new SimpleLinkedList<int>(1);
Assert.That(list.Value, Is.EqualTo(1));
}
public Node <int> FindFromBackRevursion(int kthFromEnd, SimpleLinkedList <int> list)
{
_kthFromEnd = kthFromEnd;
IterateBack(list.Head);
return(_kthNode);
}
public void Two_item_list_second_item_has_no_next()
{
var list = new SimpleLinkedList <int>(2).Add(1);
Assert.That(list.Next.Next, Is.Null);
}
public void Two_item_list_first_value()
{
var list = new SimpleLinkedList <int>(2).Add(1);
Assert.Equal(2, list.Value);
}
public void Implements_enumerable()
{
var values = new SimpleLinkedList <int>(2).Add(1).AsEnumerable();
Assert.That(values, Is.EqualTo(new[] { 2, 1 }));
}
public void Two_item_list_second_value()
{
var list = new SimpleLinkedList <int>(2).Add(1);
Assert.Equal(1, list.Next.Value);
}
public void TestInitialze()
{
this.linkedList = new SimpleLinkedList <int>();
}
public void Implements_enumerable()
{
var values = new SimpleLinkedList <int>(2).Add(1);
Assert.Equal(new[] { 2, 1 }, values);
}
private SimpleLinkedList(T value, SimpleLinkedList <T> next)
: this(value)
{
Next = next;
}
public void Single_item_list_value()
{
var list = new SimpleLinkedList <int>(1);
Assert.Equal(1, list.Value);
}
public void Setup()
{
simpleLinkedList = new SimpleLinkedList();
}
public SimpleLinkedList(T value)
{
Value = value;
Next = null;
_head = this;
}
public SimpleLinkedList(T value)
{
this.value = value;
this.next = null;
}
public void Two_item_list_second_item_has_no_next()
{
var list = new SimpleLinkedList<int>(2).Add(1);
Assert.That(list.Next.Next, Is.Null);
}
public SimpleLinkedList(T value, SimpleLinkedList <T> next = null)
{
Value = value;
Next = next;
}
public SimpleLinkedList <T> Add(T value)
{
Next = new SimpleLinkedList <T>(value);
return(this);
}
internal SimpleLinkedList<Node> GetNodesForMessage(RelayMessage message)
{
if (!Activated)
{
return new SimpleLinkedList<Node>();
}
NodeCluster cluster;
SimpleLinkedList<Node> nodes = null;
//messages that, from out of system, go to each cluster
if(message.IsClusterBroadcastMessage)
{
if (MyCluster == null) //out of system, each cluster
{
nodes = new SimpleLinkedList<Node>();
for (int clusterIndex = 0; clusterIndex < Clusters.Count; clusterIndex++)
{
nodes.Push(Clusters[clusterIndex].GetNodesForMessage(message));
}
}
else //in system, my cluster
{
nodes = MyCluster.GetNodesForMessage(message);
}
}
else
{
//messages that route to one modded cluster
//to modded cluster in group
cluster = GetClusterForId(message.Id, message.IsInterClusterMsg);
if (cluster != null)
{
if (message.IsInterClusterMsg && cluster.MeInThisCluster)
{
nodes = new SimpleLinkedList<Node>();
nodes.Push(cluster.Me);
}
else
{
nodes = cluster.GetNodesForMessage(message);
}
}
else
{
nodes = new SimpleLinkedList<Node>();
}
}
return nodes;
}
public void IsEmpty_ReturnsTrueIfListIsEmpty()
{
SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();
Assert.True(linkedList.IsEmpty);
}
