public int ReadLength()
        {
            var buffer       = m_buffer.Array;
            var extrasLength = buffer[Offset.ExtrasLength];

            Debug.Assert(extrasLength == 4, "Flags.length == 4");
            return(BigEndianConverter.GetInt32(buffer, Offset.TotalBodyLength) - extrasLength);
        }
        public int ReadFlags()
        {
            var buffer = m_buffer.Array;
            var length = buffer[Offset.ExtrasLength];

            Debug.Assert(length == 4, "Flags.length == 4");

            return(BigEndianConverter.GetInt32(buffer, Offset.Flags));
        }
Exemple #3
0
        public static void Convert_Int32()
        {
            // Arrange
            var value = RandomHelper.NextInt(g_random, Int32.MinValue, Int32.MaxValue - 1);

            // Act
            var bytes  = BigEndianConverter.GetBytes(value);
            var result = BigEndianConverter.GetInt32(bytes, 0);

            // Assert
            Assert.Equal(value, result);
        }
Exemple #4
0
        public void WriteTo()
        {
            // Arrange
            int result = 0;

            m_mockBinaryWriter.Setup(writer => writer.Write(It.IsAny <byte[]>(), 0, It.IsAny <int>()))
            .Callback <byte[], int, int>((b, i, c) =>
            {
                result = BigEndianConverter.GetInt32(b, 8);
            }).Returns(0);
            m_builder.Reset();
            m_builder.WriteOperation(RequestOperation.Set);
            m_builder.WriteFlags(1234);
            m_builder.WriteKey(Encoding.ASCII.GetBytes("Hello"));
            m_builder.WriteValue(new ArraySegment <byte>(Encoding.ASCII.GetBytes("World")));

            // Act
            m_builder.WriteTo(m_mockBinaryWriter.Object);

            // Assert
            Assert.Equal(14, result);
        }
Exemple #5
0
        public void WriteExpires()
        {
            // Arrange
            int extra  = -1;
            int result = -1;

            m_mockBinaryWriter.Setup(writer => writer.Write(It.IsAny <byte[]>(), 0, It.IsAny <int>()))
            .Callback <byte[], int, int>((b, i, c) =>
            {
                extra  = b[4];
                result = BigEndianConverter.GetInt32(b, 24);
            }).Returns(0);
            m_builder.Reset();
            m_builder.WriteOperation(RequestOperation.Set);

            // Act
            m_builder.WriteExpires(123456789);

            // Assert
            m_builder.WriteTo(m_mockBinaryWriter.Object);
            Assert.Equal(0, extra);
            Assert.Equal(123456789, result);
        }
        public ResponseStatus ReadStatus()
        {
            var buffer = m_buffer.Array;

            BinaryReaderHelper.ReadTo(m_reader, buffer, 0, Offset.EndOfHeader);

            var totalLength = BigEndianConverter.GetInt32(buffer, Offset.TotalBodyLength);

            m_buffer.EnsureCapacity(Offset.EndOfHeader + totalLength);
            BinaryReaderHelper.ReadTo(m_reader, buffer, Offset.EndOfHeader, totalLength);

            var status = (ResponseStatus)m_buffer.Array[Offset.Status];

            if (status == ResponseStatus.NoError)
            {
                if (buffer[Offset.OperationCode] == 0x00)
                {
                    status = ResponseStatus.Value;
                }
            }

            return(status);
        }