public void WillCompleteNewLine()
 {
     // Arrange
     var buffer = new ChunkBuffer();
     byte[] data = Encoding.UTF8.GetBytes("hello");
     buffer.Add(data, data.Length);
     Assert.Null(buffer.ReadLine());
     data = Encoding.UTF8.GetBytes("\n");
     buffer.Add(data, data.Length);
     Assert.Equal("hello", buffer.ReadLine());
     data = Encoding.UTF8.GetBytes("Another line");
     buffer.Add(data, data.Length);
     Assert.Null(buffer.ReadLine());
     data = Encoding.UTF8.GetBytes("\nnext");
     buffer.Add(data, data.Length);
     Assert.Equal("Another line", buffer.ReadLine());
 }
            public void WillCompleteNewLine()
            {
                // Arrange
                var buffer = new ChunkBuffer();

                byte[] data = Encoding.UTF8.GetBytes("hello");
                buffer.Add(data, data.Length);
                Assert.Null(buffer.ReadLine());
                data = Encoding.UTF8.GetBytes("\n");
                buffer.Add(data, data.Length);
                Assert.Equal("hello", buffer.ReadLine());
                data = Encoding.UTF8.GetBytes("Another line");
                buffer.Add(data, data.Length);
                Assert.Null(buffer.ReadLine());
                data = Encoding.UTF8.GetBytes("\nnext");
                buffer.Add(data, data.Length);
                Assert.Equal("Another line", buffer.ReadLine());
            }
            public void ReturnsTextUpToNewLine()
            {
                // Arrange
                var buffer = new ChunkBuffer();
                byte[] data = Encoding.UTF8.GetBytes("hello world\noy");

                // Act
                buffer.Add(data, data.Length);

                // Assert
                Assert.Equal("hello world", buffer.ReadLine());
            }
            public void ReturnsNullIfNoNewLineIfBuffer()
            {
                // Arrange
                var buffer = new ChunkBuffer();
                byte[] data = Encoding.UTF8.GetBytes("hello world");

                // Act
                buffer.Add(data, data.Length);

                // Assert
                Assert.Null(buffer.ReadLine());
            }
Exemple #5
0
        private void ReadLoop()
        {
            if (!Reading)
            {
                return;
            }

            var _buffer = new byte[1024];
            var _signal = new EventSignal <CallbackDetail <int> >();

            _signal.Finished += (sender, e) =>
            {
                if (e.Result.IsFaulted)
                {
                    Exception exception = e.Result.Exception.GetBaseException();

                    if (!HttpBasedTransport.IsRequestAborted(exception))
                    {
                        if (!(exception is IOException))
                        {
                            m_connection.OnError(exception);
                        }
                        StopReading(true);
                    }
                    return;
                }

                int _read = e.Result.Result;

                if (_read > 0)
                {
                    // Put chunks in the buffer
                    m_buffer.Add(_buffer, _read);
                }

                if (_read == 0)
                {
                    // Stop any reading we're doing
                    StopReading(true);
                    return;
                }

                // Keep reading the next set of data
                ReadLoop();

                if (_read <= _buffer.Length)
                {
                    // If we read less than we wanted or if we filled the buffer, process it
                    ProcessBuffer();
                }
            };
            StreamExtensions.ReadAsync(_signal, m_stream, _buffer);
        }
            public void ReturnsTextUpToNewLine()
            {
                // Arrange
                var buffer = new ChunkBuffer();

                byte[] data = Encoding.UTF8.GetBytes("hello world\noy");

                // Act
                buffer.Add(data, data.Length);

                // Assert
                Assert.Equal("hello world", buffer.ReadLine());
            }
            public void ReturnsNullIfNoNewLineIfBuffer()
            {
                // Arrange
                var buffer = new ChunkBuffer();

                byte[] data = Encoding.UTF8.GetBytes("hello world");

                // Act
                buffer.Add(data, data.Length);

                // Assert
                Assert.Null(buffer.ReadLine());
            }
        private void ReadLoop()
        {
            if (!Reading)
            {
                return;
            }

            var buffer = new byte[1024];

            _stream.ReadAsync(buffer).ContinueWith(task =>
            {
                if (task.Exception != null)
                {
                    var exception = task.Exception.GetBaseException();

                    if (!HttpBasedTransport.IsRequestAborted(exception))
                    {
                        if (!(exception is IOException))
                        {
                            _connection.OnError(exception);
                        }
                        StopReading(true);
                    }
                    return;
                }

                var read = task.Result;

                // Put chunks in the buffer
                if (read > 0)
                {
                    _buffer.Add(buffer, read);
                }

                // Stop any reading we're doing
                if (read == 0)
                {
                    StopReading(true);
                    return;
                }

                // Keep reading the next set of data
                ReadLoop();

                // If we read less than we wanted or if we filled the buffer, process it
                if (read <= buffer.Length)
                {
                    ProcessBuffer();
                }
            });
        }
            public void CanReadMultipleLines()
            {
                // Arrange
                var buffer = new ChunkBuffer();
                byte[] data = Encoding.UTF8.GetBytes("hel\nlo world\noy");

                // Act
                buffer.Add(data, data.Length);

                // Assert
                Assert.Equal("hel", buffer.ReadLine());
                Assert.Equal("lo world", buffer.ReadLine());
                Assert.Null(buffer.ReadLine());
            }
            public void CanReadMultipleLines()
            {
                // Arrange
                var buffer = new ChunkBuffer();

                byte[] data = Encoding.UTF8.GetBytes("hel\nlo world\noy");

                // Act
                buffer.Add(data, data.Length);

                // Assert
                Assert.Equal("hel", buffer.ReadLine());
                Assert.Equal("lo world", buffer.ReadLine());
                Assert.Null(buffer.ReadLine());
            }