public void LTChatDecodeTest()
        {
            LTChat m = new LTChat(LTChat.Support.MessageId, "This Is My Message");

            byte[] data    = m.Encode();
            LTChat decoded = (LTChat)PeerMessage.DecodeMessage(data, 0, data.Length, null);

            Assert.AreEqual(m.Message, decoded.Message, "#1");
        }
        private void EncodeDecode(Message orig)
        {
            orig.Encode(buffer, offset);
            Message dec = PeerMessage.DecodeMessage(buffer, offset, orig.ByteLength, torrentData);

            Assert.IsTrue(orig.Equals(dec), $"orig: {orig}, new: {dec}");

            Assert.IsTrue(Toolbox.ByteMatch(orig.Encode(), PeerMessage.DecodeMessage(orig.Encode(), 0, orig.ByteLength, torrentData).Encode()));
        }
        public void BitfieldCorrupt()
        {
            Assert.Throws <MessageException> (() => {
                bool[] data    = { true, false, false, true, false, true, false, true, false, true, false, true, false, false, false, true };
                byte[] encoded = new BitfieldMessage(new BitField(data)).Encode();

                PeerMessage.DecodeMessage(encoded, 0, encoded.Length, null);
            });
        }
        public void PeerExchangeMessageDecode()
        {
            // Decodes as: 192.168.0.1:100
            byte[] peer     = { 192, 168, 0, 1, 100, 0 };
            byte[] supports = { 1 | 2 }; // 1 == encryption, 2 == seeder

            byte id = PeerExchangeMessage.Support.MessageId;
            PeerExchangeMessage message = new PeerExchangeMessage(id, peer, supports, null);

            byte[] buffer         = message.Encode();
            PeerExchangeMessage m = (PeerExchangeMessage)PeerMessage.DecodeMessage(buffer, 0, buffer.Length, null);

            Assert.IsTrue(Toolbox.ByteMatch(peer, m.Added), "#1");
            Assert.IsTrue(Toolbox.ByteMatch(supports, m.AddedDotF), "#1");
        }
        public void HandshakeDecodeTest()
        {
            ExtendedHandshakeMessage m = new ExtendedHandshakeMessage(false, 123, 5555);

            byte[] data = m.Encode();
            ExtendedHandshakeMessage decoded = (ExtendedHandshakeMessage)PeerMessage.DecodeMessage(data, 0, data.Length, null);

            Assert.AreEqual(m.ByteLength, data.Length);
            Assert.AreEqual(m.ByteLength, decoded.ByteLength, "#1");
            Assert.AreEqual(m.LocalPort, decoded.LocalPort, "#2");
            Assert.AreEqual(m.MaxRequests, decoded.MaxRequests, "#3");
            Assert.AreEqual(m.Version, decoded.Version, "#4");
            Assert.AreEqual(m.Supports.Count, decoded.Supports.Count, "#5");
            m.Supports.ForEach(delegate(ExtensionSupport s) { Assert.IsTrue(decoded.Supports.Contains(s), "#6:" + s); });
        }
        public void BitFieldEncoding()
        {
            bool[] data = { true,  false, false, true,  false, true,  false, true,  false, true,
                            false, true,  false, false, false, true,  true,  true,  false, false,
                            false, true,  false, true,  false, false, true,  false, true,  false,
                            true,  true,  false, false, true,  false, false, true,  true,  false };

            Assert.AreEqual(data.Length, (int)Math.Ceiling((double)torrentData.Size / torrentData.PieceLength), "#0");
            byte[] encoded = new BitfieldMessage(new BitField(data)).Encode();

            BitfieldMessage m = (BitfieldMessage)PeerMessage.DecodeMessage(encoded, 0, encoded.Length, torrentData);

            Assert.AreEqual(data.Length, m.BitField.Length, "#1");
            for (int i = 0; i < data.Length; i++)
            {
                Assert.AreEqual(data[i], m.BitField[i], "#2." + i);
            }
        }
        public void BitFieldDecoding()
        {
            byte[]          buf = { 0x00, 0x00, 0x00, 0x04, 0x05, 0xff, 0x08, 0xAA, 0xE3, 0x00 };
            BitfieldMessage msg = (BitfieldMessage)PeerMessage.DecodeMessage(buf, 0, 8, torrentData);

            for (int i = 0; i < 8; i++)
            {
                Assert.IsTrue(msg.BitField[i], i.ToString());
            }

            for (int i = 8; i < 12; i++)
            {
                Assert.IsFalse(msg.BitField[i], i.ToString());
            }

            Assert.IsTrue(msg.BitField[12], 12.ToString ());
            for (int i = 13; i < 15; i++)
            {
                Assert.IsFalse(msg.BitField[i], i.ToString());
            }
            EncodeDecode(msg);
        }