public TLV(byte[] bytes, int offset)
 {
     ByteArraySegment byteArraySegment = new ByteArraySegment(bytes, offset, 2);
     this.TypeLength = new TLVTypeLength(byteArraySegment);
     this.tlvData = new ByteArraySegment(bytes, offset, this.TypeLength.Length + 2);
     this.tlvData.Length = this.TypeLength.Length + 2;
 }

            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="bas">
            /// A <see cref="ByteArraySegment"/>
            /// </param>
            public ProbeRequestFrame (ByteArraySegment bas)
            {
                header = new ByteArraySegment (bas);

                FrameControl = new FrameControlField (FrameControlBytes);
                Duration = new DurationField (DurationBytes);
                DestinationAddress = GetAddress (0);
                SourceAddress = GetAddress (1);
                BssId = GetAddress (2);
                SequenceControl = new SequenceControlField (SequenceControlBytes);
				
				if(bas.Length > ProbeRequestFields.InformationElement1Position)
				{
                	//create a segment that just refers to the info element section
                	ByteArraySegment infoElementsSegment = new ByteArraySegment (bas.Bytes,
                    	(bas.Offset + ProbeRequestFields.InformationElement1Position),
                    	(bas.Length - ProbeRequestFields.InformationElement1Position));

                	InformationElements = new InformationElementList (infoElementsSegment);
				}
				else
				{
					InformationElements = new InformationElementList ();
				}
                //cant set length until after we have handled the information elements
                //as they vary in length
                header.Length = FrameSize;
            }

        internal void HandleTcpReceived(uint sequenceNumber, ByteArraySegment data)
        {
            var dataPosition = SequenceNumberToBytesReceived(sequenceNumber);
            if (dataPosition == BytesReceived)
            {
                OnDataReceived(data);
                BytesReceived += data.Length;
            }
            else
            {
                var dataArray = new byte[data.Length];
                Array.Copy(data.Bytes, data.Offset, dataArray, 0, data.Length);
                if (!_bufferedPackets.ContainsKey(dataPosition) ||
                    _bufferedPackets[dataPosition].Length < dataArray.Length)
                {
                    _bufferedPackets[dataPosition] = dataArray;
                }
            }

            long firstBufferedPosition;
            while (_bufferedPackets.Any() && ((firstBufferedPosition = _bufferedPackets.Keys.First()) <= BytesReceived))
            {
                var dataArray = _bufferedPackets[firstBufferedPosition];
                _bufferedPackets.Remove(firstBufferedPosition);

                var alreadyReceivedBytes = BytesReceived - firstBufferedPosition;
                Debug.Assert(alreadyReceivedBytes >= 0);

                if (alreadyReceivedBytes >= dataArray.Length) continue;
                var count = dataArray.Length - alreadyReceivedBytes;
                OnDataReceived(new ByteArraySegment(dataArray, (int) alreadyReceivedBytes, (int) count));
                BytesReceived += count;
            }
        }

            public void Test_Constructor_ConstructWithValues ()
            {
                AckFrame frame = new AckFrame (PhysicalAddress.Parse ("111111111111"));
                
                frame.FrameControl.ToDS = false;
                frame.FrameControl.FromDS = true;
                frame.FrameControl.MoreFragments = true;
                
                frame.Duration.Field = 0x1234;
                
                frame.UpdateFrameCheckSequence ();
                UInt32 fcs = frame.FrameCheckSequence;
                
                //serialize the frame into a byte buffer
                var bytes = frame.Bytes;
                var bas = new ByteArraySegment (bytes);

                //create a new frame that should be identical to the original
                AckFrame recreatedFrame = MacFrame.ParsePacket (bas) as AckFrame;
                recreatedFrame.UpdateFrameCheckSequence ();
                
                Assert.AreEqual (FrameControlField.FrameSubTypes.ControlACK, recreatedFrame.FrameControl.SubType);
                Assert.IsFalse (recreatedFrame.FrameControl.ToDS);
                Assert.IsTrue (recreatedFrame.FrameControl.FromDS);
                Assert.IsTrue (recreatedFrame.FrameControl.MoreFragments);
                
                Assert.AreEqual ("111111111111", recreatedFrame.ReceiverAddress.ToString ().ToUpper ());
                
                Assert.AreEqual (fcs, recreatedFrame.FrameCheckSequence);
            }

 public FloodFiller(ByteArraySegment skin, int skinwidth, int skinheight)
 {
     _Skin = skin;
     _Width = skinwidth;
     _Height = skinheight;
     _Fifo = new floodfill_t[FLOODFILL_FIFO_SIZE];
     _FillColor = _Skin.Data[_Skin.StartIndex]; // *skin; // assume this is the pixel to fill
 }

            public void Test_Constructor_EmptyByteArray ()
            {
                ByteArraySegment bas = new ByteArraySegment (new Byte[0]);
                InformationElementList ieList = new InformationElementList (bas);

                Assert.AreEqual (0, ieList.Count);
                Assert.AreEqual (0, ieList.Length);
            }

		/// <summary>
		/// Create from a type and string value
		/// </summary>
		/// <param name="tlvType">
		/// A <see cref="TLVTypes"/>
		/// </param>
		/// <param name="StringValue">
		/// A <see cref="System.String"/>
		/// </param>
		public StringTLV(TLVTypes tlvType, string StringValue) {
			var bytes = new byte[TLVTypeLength.TypeLengthLength];
			var offset = 0;
			tlvData = new ByteArraySegment(bytes, offset, bytes.Length);

			Type = tlvType;
			this.StringValue = StringValue;
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="bas">
		/// A <see cref="ByteArraySegment"/>
		/// </param>
		public IGMPv2Packet(ByteArraySegment bas) {
			// set the header field, header field values are retrieved from this byte array
			header = new ByteArraySegment(bas);
			header.Length = UdpFields.HeaderLength;

			// store the payload bytes
			payloadPacketOrData = new PacketOrByteArraySegment();
			payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes();
		}

        public Decoder(int bufsize, long maxmsgsize)
            : base(bufsize)
        {
            m_maxmsgsize = maxmsgsize;
            m_tmpbuf = new ByteArraySegment(new byte[8]);

            //  At the beginning, read one byte and go to one_byte_size_ready state.
            NextStep (m_tmpbuf, 1, OneByteSizeReadyState);
        }

            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="bas">
            /// A <see cref="ByteArraySegment"/>
            /// </param>
            public CtsFrame (ByteArraySegment bas)
            {
                header = new ByteArraySegment (bas);

                FrameControl = new FrameControlField (FrameControlBytes);
                Duration = new DurationField (DurationBytes);
                ReceiverAddress = GetAddress(0);
				
				header.Length = FrameSize;
            }

		/// <summary>
		/// Creates a System Capabilities TLV and sets the value
		/// </summary>
		/// <param name="capabilities">
		/// A bitmap containing the available System Capabilities
		/// </param>
		/// <param name="enabled">
		/// A bitmap containing the enabled System Capabilities
		/// </param>
		public SystemCapabilities(ushort capabilities, ushort enabled) {
			var length = TLVTypeLength.TypeLengthLength + SystemCapabilitiesLength + EnabledCapabilitiesLength;
			var bytes = new byte[length];
			var offset = 0;
			tlvData = new ByteArraySegment(bytes, offset, length);

			Type = TLVTypes.SystemCapabilities;
			Capabilities = capabilities;
			Enabled = enabled;
		}

 public void Test_Constructor_BufferTooShort ()
 {
     //This IE will have and length of 5 but only three bytes of data
     Byte[] value = new Byte[] { 0x0, 0x5, 0x1, 0x2, 0x3 };
     ByteArraySegment bas = new ByteArraySegment (value);
     
     InformationElement infoElement = new InformationElement (bas);
     
     Assert.AreEqual (3, infoElement.ValueLength);
     Assert.AreEqual (3, infoElement.Value.Length);
 }

            /// <summary>
            /// Initializes a new instance of the <see cref="PacketDotNet.Ieee80211.NullDataFrame"/> class.
            /// </summary>
            /// <param name='bas'>
            /// A <see cref="ByteArraySegment"/>
            /// </param>
            public NullDataFrame (ByteArraySegment bas)
            {
                header = new ByteArraySegment (bas);

                FrameControl = new FrameControlField (FrameControlBytes);
                Duration = new DurationField (DurationBytes);
                SequenceControl = new SequenceControlField (SequenceControlBytes);
                ReadAddresses ();
                
                header.Length = FrameSize;
            }

 public void Test_Constructor_BufferLongerThanElement ()
 {
     //This IE will have and length of 2 but there are three bytes of data available,
     //the last one should be ignored
     Byte[] value = new Byte[] { 0x0, 0x2, 0x1, 0x2, 0x3 };
     ByteArraySegment bas = new ByteArraySegment (value);
     
     InformationElement infoElement = new InformationElement (bas);
     
     Assert.AreEqual (2, infoElement.ValueLength);
     Assert.AreEqual (2, infoElement.Value.Length);
 }

        /// <summary>
        /// Create a new V1Decoder with the given buffer-size, maximum-message-size and Endian-ness.
        /// </summary>
        /// <param name="bufsize">the buffer-size to give the contained buffer</param>
        /// <param name="maxMessageSize">the maximum message size. -1 indicates no limit.</param>
        /// <param name="endian">the Endianness to specify for it - either Big or Little</param>
        public V1Decoder(int bufsize, long maxMessageSize, Endianness endian)
            : base(bufsize, endian)
        {
            m_maxMessageSize = maxMessageSize;
            m_tmpbuf = new ByteArraySegment(new byte[8]);

            //  At the beginning, read one byte and go to one_byte_size_ready state.
            NextStep(m_tmpbuf, 1, OneByteSizeReadyState);

            m_inProgress = new Msg();
            m_inProgress.InitEmpty();
        }

        public void device_OnPacketArrival(object sender, CaptureEventArgs eCap)
        {
            try
            {
                ByteArraySegment raw = new ByteArraySegment(eCap.Packet.Data);
                EthernetPacket ethernetPacket = new EthernetPacket(raw);
                IpPacket ipPacket = (IpPacket)ethernetPacket.PayloadPacket;
                TcpPacket tcp = (TcpPacket)ipPacket.PayloadPacket;

                if (ipPacket != null && tcp != null)
                {
                    string destIp = ipPacket.DestinationAddress.ToString();

                    if (destIp == captureIp)
                    {
                        //Client -> Server
                        MainWindow.pp.AppendClientData(tcp.PayloadData);

                        // ReSharper disable CSharpWarnings::CS0642
                        while (MainWindow.pp.ProcessClientData()) ;
                        // ReSharper restore CSharpWarnings::CS0642

                    }
                    else
                    {
                        //Do a check for a new game Connection. Each handshake starts with a dword 1 packet from the server.
                        byte[] test = { 0x01, 0x00, 0x00, 0x00 };
                        if (StructuralComparisons.StructuralEqualityComparer.Equals(test, tcp.PayloadData))
                        {
                            //New Connection detected.
                            //We should reset State and Security Info
                            MainWindow.pp.Init();
                            MainWindow.pp.State = 0;
                            MainWindow.ClearPackets();
                        }

                        //Sever -> Client
                        MainWindow.pp.AppendServerData(tcp.PayloadData);
                        // ReSharper disable CSharpWarnings::CS0642
                        while (MainWindow.pp.ProcessServerData()) ;
                        // ReSharper restore CSharpWarnings::CS0642
                    }

                }
            }
            catch (Exception ex)
            {

                MainWindow.SetText("device_OnPacketArrival failure. \n Message:" + ex);
            }
        }

            /// <summary>
            /// Initializes a new instance of the <see cref="PacketDotNet.Ieee80211.DataDataFrame"/> class.
            /// </summary>
            /// <param name='bas'>
            /// Bas.
            /// </param>
            public DataDataFrame (ByteArraySegment bas)
            {
                header = new ByteArraySegment (bas);

                FrameControl = new FrameControlField (FrameControlBytes);
                Duration = new DurationField (DurationBytes);
                SequenceControl = new SequenceControlField (SequenceControlBytes);
                ReadAddresses (); //must do this after reading FrameControl

                header.Length = FrameSize; 
                var availablePayloadLength = GetAvailablePayloadLength();
				if(availablePayloadLength > 0)
				{
					payloadPacketOrData.TheByteArraySegment = header.EncapsulatedBytes (availablePayloadLength);
				}
            }

        public void Init( PgmAddress pgmAddress)
        {
            m_pgmAddress = pgmAddress;

            m_pgmSocket = new PgmSocket(m_options, PgmSocketType.Publisher, (PgmAddress)m_addr.Resolved);
            m_pgmSocket.Init();

            m_socket = m_pgmSocket.Handle;

            var localEndpoint = new IPEndPoint(IPAddress.Any, 0);

            m_socket.Bind(localEndpoint);

            m_pgmSocket.InitOptions();

            m_outBufferSize = Config.PgmMaxTPDU;
            m_outBuffer = new ByteArraySegment(new byte[m_outBufferSize]);
        }

        public void IntLittleEndian()
        {
            ByteArraySegment byteArraySegment = new ByteArraySegment(new byte[4]);

            byteArraySegment.PutInteger(Endianness.Little, 1, 0);

            Assert.AreEqual(1, byteArraySegment[0]);
            Assert.AreEqual(0, byteArraySegment[3]);

            long num = byteArraySegment.GetInteger(Endianness.Little, 0);

            Assert.AreEqual(1, num);

            byteArraySegment.PutInteger(Endianness.Little, 16777216, 0);

            Assert.AreEqual(1, byteArraySegment[3]);
            Assert.AreEqual(0, byteArraySegment[0]);

            num = byteArraySegment.GetInteger(Endianness.Little, 0);

            Assert.AreEqual(16777216, num);
        }

        public void LongLittleEndian()
        {
            ByteArraySegment byteArraySegment = new ByteArraySegment(new byte[8]);

            byteArraySegment.PutLong(Endianness.Little, 1, 0);

            Assert.AreEqual(byteArraySegment[0], 1);
            Assert.AreEqual(0, byteArraySegment[7]);

            long num = byteArraySegment.GetLong(Endianness.Little, 0);

            Assert.AreEqual(1, num);

            byteArraySegment.PutLong(Endianness.Little, 72057594037927936, 0);

            Assert.AreEqual(1, byteArraySegment[7]);
            Assert.AreEqual(0, byteArraySegment[0]);

            num = byteArraySegment.GetLong(Endianness.Little, 0);

            Assert.AreEqual(72057594037927936, num);
        }