public void TestTokenMessage()
        {
            TokenMessage msg = new TokenMessage();
            msg.EncodeHiddenComm("A", "B");
            TokenMessage msgTwo = new TokenMessage();

            msgTwo.Decode(msg.ToSend);
            CompareTokenMessages(msg, msgTwo);

            msg.EncodeMessage("C", "D", "hello!! :D |");
            msgTwo.Decode(msg.ToSend);
            CompareTokenMessages(msg, msgTwo);
        }
        private void CompareTokenMessages(TokenMessage msg, TokenMessage msgTwo)
        {
            Assert.AreEqual(msg.Destination, msgTwo.Destination);
            Assert.AreEqual(msg.Sender, msgTwo.Sender);
            Assert.AreEqual(msg.Token, msgTwo.Token);
            Assert.AreEqual(msg.Info, msgTwo.Info);

            int len = 0;
            if (msg.ToSend.Length >= msgTwo.ToSend.Length)
            {
                len = msg.ToSend.Length;
            }
            else
            {
                len = msgTwo.ToSend.Length;
            }

            for (int i = 0; i < len; i++)
            {
                Assert.AreEqual(msg.ToSend[i], msgTwo.ToSend[i]);
            }
        }
        /// <summary>
        /// The instance so that we can send a message or token.
        /// </summary>
        private void sender()
        {
            int numConnected = 0;
            while (numConnected != this.nodeCount)
            {
                lock (this.nodes)
                {
                    numConnected = this.nodes.Count;
                }
                Thread.Sleep(100);
            }

            TokenMessage msg = new TokenMessage();
            msg.EncodeHiddenComm(GlobalConst.serverName, GlobalConst.serverName);

            lock (this.nodes)
            {
                NetworkStream stream = this.nodes.First().GetStream();
            }
            //Need to check the index
            curIndex = 0;
            this.tokenCount++;
            lock (stopwatch)
            {
                stopwatch.Start();
            }

            //Send first token
            //Set a stopwatch and then use that stopwatch here.
            //Every time ANY tcpclient receives something, reset stopwatch.
            //If the stopwatch runs out, resend token ad infinitum until SOMETHING tells it to stop
            //That something is up to you.
            while (!interrupted)
            {
                TcpClient client = null;
                lock(this.nodes)
                {
                    client = this.nodes[curIndex];
                }
                actuallySend(client, msg);
                while (stopwatch.Elapsed.TotalSeconds < 5)
                {
                    Thread.Sleep(2500);
                    if(!stopwatch.IsRunning)
                    {
                        stopwatch.Start();
                    }
                }
            }
        }
        /// <summary>
        /// Handles the client comm. STarts a new thread for each node.
        /// </summary>
        /// <param name="clientObject">The client object.</param>
        private void HandleClientComm(object clientObject)
        {
            try
            {
                TcpClient client = (TcpClient)clientObject;
                NetworkStream clientStream = client.GetStream();
                TokenMessage msg = new TokenMessage();
                byte[] message;
                int bytesRead;

                while (true)
                {
                    bytesRead = 0;
                    message = GlobalConst.getSpaceByteArray(GlobalConst.BUFSIZE);

                    try
                    {
                        //blocks until a client sends a message
                        bytesRead = clientStream.Read(message, 0, GlobalConst.BUFSIZE);
                        lock (stopwatch)
                        {
                            stopwatch.Reset();
                        }
                        //Console.WriteLine("Got a message on tokenHub");
                        //RESET STOPWATCH

                    }
                    catch
                    {
                        //a socket error has occured
                        break;
                    }

                    if (bytesRead == 0)
                    {
                        //the client has disconnected from the server
                        break;
                    }

                    bool good = msg.Decode(message);
                    if (msg.Token)
                    {
                        //SEND TOKEN TO NEXT PERSON
                        this.tokenCount++;
                        lock(this.nodes)
                        {
                            if (this.tokenCount >= this.nodes.Count)
                            {
                                break;
                            }
                        }
                    }
                    else if (!good)
                    {
                        continue;
                    }
                    else
                    {
                        this.tokenCount = 0;
                    }

                    int index = nodes.IndexOf(client) + 1;
                    int max = nodes.Count;
                    if (index >= max)
                    {
                        index = 0;
                    }

                    curIndex = index;

                    TcpClient clientNew = null;

                    lock(this.nodes)
                    {
                        clientNew = this.nodes[curIndex];
                    }

                    actuallySend(clientNew, msg);

                    //message has successfully been received
                    //Send it to the next node. get the index of the current tcpclient then call send.
                }
            }
            catch (ThreadInterruptedException)
            {
                TcpClient c = (TcpClient)clientObject;
                c.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
 /// <summary>
 /// Actuallies the SwitchSend.
 /// </summary>
 /// <param name="client">The client.</param>
 /// <param name="msg">The MSG.</param>
 private void actuallySend(TcpClient client, TokenMessage msg)
 {
     stopwatch.Reset();
     client.GetStream().Write(msg.ToSend, 0, msg.ToSend.Length);
     client.GetStream().Flush();
 }
        /// <summary>
        /// Tokens the sending.
        /// </summary>
        private void TokenSending()
        {
            int toSendCount = 0;
            char[] sep = { ',' };

            NetworkStream stream = this.client.GetStream();

            lock (ToSend)
            {
                toSendCount = ToSend.Count;
            }

            try
            {
                while (toSendCount > 0)
                {
                    while (!this.hasToken)
                    {
                        try
                        {
                            Thread.Sleep(Timeout.Infinite);
                        }
                        catch(ThreadAbortException)
                        {
                            throw;
                        }
                        catch
                        {
                            ;
                        }

                        if (!this.hasToken)
                        {
                            Console.WriteLine("Sending for node {0} received an interrupt when it wasn't supposed to.", parentNode.Name);
                        }
                    }

                    String msgToSend = toSend.Peek();
                    String[] info = msgToSend.Split(sep, 2);
                    TokenMessage msg = new TokenMessage();
                    msg.EncodeMessage(this.parentNode.Name, info[0], info[1]);

                    if (this.parentNode.GetRandomNum() < GlobalConst.errorPerc)
                    {
                        msg.ToSend[4] = 0;
                    }

                    UseDelegate(stream, msg);

                    //ASSUMING NO ERRORS. Need to update once errors have been put in.
                    try
                    {
                        Thread.Sleep(GlobalConst.TokenTimer * 1000);
                        continue;
                    }
                    catch(ThreadAbortException)
                    {
                        throw;
                    }
                    catch
                    {
                        ;
                    }

                    lock (ToSend)
                    {
                        toSendCount = this.toSend.Count;
                    }
                }

                this.doneSending = true;
            }
            catch (ThreadAbortException)
            {

            }
        }
        /// <summary>
        /// Tokens the listening.
        /// </summary>
        private void TokenListening()
        {
            int bytesRead = 0;
            int countTimesSent = 0;
            byte[] message;
            NetworkStream stream = this.client.GetStream();
            TokenMessage token = new TokenMessage(); //Whenever we receive something, we ALWAYS send something back.

            while (true)
            {
                bytesRead = 0;
                message = GlobalConst.getSpaceByteArray(GlobalConst.BUFSIZE);

                try
                {
                    bytesRead = stream.Read(message, 0, GlobalConst.BUFSIZE);
                }
                catch
                {
                    //socket error. WTF.
                    break;
                }

                if(bytesRead == 0)
                {
                    break;
                }

                TokenMessage msg = new TokenMessage();
                bool msgOK = msg.Decode(message);

                if(msg.Token)
                {

                    //Console.WriteLine("Got token on Node " + this.parentNode.Name);
                    this.hasToken = true;

                    if (this.senderThread.ThreadState.Equals(ThreadState.Stopped))
                    {
                        UseDelegate(stream, msg);
                    }
                    else
                    {
                        while (this.SenderThread.ThreadState.Equals(ThreadState.WaitSleepJoin) == false)
                        {
                            Thread.Sleep(50);
                        }

                        this.SenderThread.Interrupt();
                    }

                }
                else if (!msgOK)
                {

                    Console.WriteLine("Got a bad message on Node " + this.parentNode.Name);
                }
                else
                {

                    //Console.WriteLine("Got message on Node {0} ", this.parentNode.Name);
                    if (msg.Sender.Equals(this.parentNode.Name))
                    {
                        if (msg.FS == '1' || countTimesSent > 3)
                        {
                            this.toSend.Dequeue();
                            token.EncodeHiddenComm(GlobalConst.serverName, GlobalConst.serverName);
                            this.hasToken = false;
                            while (!this.senderThread.ThreadState.Equals(ThreadState.WaitSleepJoin))
                            {
                                Thread.Sleep(50);
                            }
                            this.SenderThread.Interrupt();
                        }
                        else
                        {
                            countTimesSent++;
                            token = msg;
                        }
                    }
                    else if (msg.Destination.Equals(this.parentNode.Name))
                    {
                        this.parentNode.writeOutMessage(msg);
                        token = msg;
                        token.FS = '1';
                    }
                    else
                    {
                        token = msg;
                    }

                    UseDelegate(stream, token);
                }
            }

            this.doneReceiving = true;
            if(!this.doneSending)
            {
                SenderThread.Abort();
            }

            while (!this.parentThread.ThreadState.Equals(ThreadState.WaitSleepJoin))
            {
                Thread.Sleep(100);
            }

            this.parentThread.Interrupt();
        }