/*
* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
*/
package org.apache.http.nio.util;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import org.apache.http.Consts;
import org.apache.http.ReadableByteChannelMock;
import org.apache.http.impl.io.HttpTransportMetricsImpl;
import org.apache.http.impl.nio.reactor.SessionOutputBufferImpl;
import org.apache.http.io.BufferInfo;
import org.apache.http.nio.ContentDecoder;
import org.apache.http.nio.ContentEncoder;
import org.apache.http.nio.reactor.SessionOutputBuffer;
import org.apache.http.util.EncodingUtils;
import org.junit.Assert;
import org.junit.Test;
/**
* Buffer tests.
*/
public class TestBuffers {
@Test
public void testInputBufferOperations() throws IOException {
final ReadableByteChannel channel = new ReadableByteChannelMock(
new String[] {"stuff;", "more stuff"}, Consts.ASCII);
final ContentDecoder decoder = new ContentDecoderMock(channel);
final SimpleInputBuffer buffer = new SimpleInputBuffer(4, DirectByteBufferAllocator.INSTANCE);
final int count = buffer.consumeContent(decoder);
Assert.assertEquals(16, count);
Assert.assertTrue(decoder.isCompleted());
final byte[] b1 = new byte[5];
int len = buffer.read(b1);
Assert.assertEquals("stuff", EncodingUtils.getAsciiString(b1, 0, len));
final int c = buffer.read();
Assert.assertEquals(';', c);
final byte[] b2 = new byte[1024];
len = buffer.read(b2);
Assert.assertEquals("more stuff", EncodingUtils.getAsciiString(b2, 0, len));
Assert.assertEquals(-1, buffer.read());
Assert.assertEquals(-1, buffer.read(b2));
Assert.assertEquals(-1, buffer.read(b2, 0, b2.length));
Assert.assertTrue(buffer.isEndOfStream());
buffer.reset();
Assert.assertFalse(buffer.isEndOfStream());
}
@Test
public void testOutputBufferOperations() throws IOException {
final ByteArrayOutputStream outstream = new ByteArrayOutputStream();
final WritableByteChannel channel = Channels.newChannel(outstream);
final SessionOutputBuffer outbuf = new SessionOutputBufferImpl(1024, 128, Consts.ASCII);
final HttpTransportMetricsImpl metrics = new HttpTransportMetricsImpl();
final ContentEncoder encoder = new ContentEncoderMock(channel, outbuf, metrics);
final SimpleOutputBuffer buffer = new SimpleOutputBuffer(4, DirectByteBufferAllocator.INSTANCE);
buffer.write(EncodingUtils.getAsciiBytes("stuff"));
buffer.write(';');
buffer.produceContent(encoder);
buffer.write(EncodingUtils.getAsciiBytes("more "));
buffer.write(EncodingUtils.getAsciiBytes("stuff"));
buffer.produceContent(encoder);
final byte[] content = outstream.toByteArray();
Assert.assertEquals("stuff;more stuff", EncodingUtils.getAsciiString(content));
}
@Test
public void testBufferInfo() throws Exception {
final SimpleOutputBuffer buffer = new SimpleOutputBuffer(8, DirectByteBufferAllocator.INSTANCE);
final BufferInfo bufferinfo = buffer;
Assert.assertEquals(0, bufferinfo.length());
Assert.assertEquals(8, bufferinfo.available());
buffer.write(new byte[] {'1', '2', '3', '4'});
Assert.assertEquals(4, bufferinfo.length());
Assert.assertEquals(4, bufferinfo.available());
buffer.write(new byte[] {'1', '2', '3', '4', '5', '6', '7', '8'});
Assert.assertEquals(12, bufferinfo.length());
Assert.assertEquals(0, bufferinfo.available());
}
@Test
public void testInputBufferNullInput() throws IOException {
final SimpleInputBuffer buffer = new SimpleInputBuffer(4, DirectByteBufferAllocator.INSTANCE);
Assert.assertEquals(0, buffer.read(null));
Assert.assertEquals(0, buffer.read(null, 0, 0));
}
@Test
public void testOutputBufferNullInput() throws IOException {
final SimpleOutputBuffer buffer = new SimpleOutputBuffer(4, DirectByteBufferAllocator.INSTANCE);
buffer.write(null);
buffer.write(null, 0, 10);
Assert.assertFalse(buffer.hasData());
}
@Test
public void testDirectByteBufferAllocator() {
final DirectByteBufferAllocator allocator = new DirectByteBufferAllocator();
ByteBuffer buffer = allocator.allocate(1);
Assert.assertNotNull(buffer);
Assert.assertTrue(buffer.isDirect());
Assert.assertEquals(0, buffer.position());
Assert.assertEquals(1, buffer.limit());
Assert.assertEquals(1, buffer.capacity());
buffer = allocator.allocate(2048);
Assert.assertTrue(buffer.isDirect());
Assert.assertEquals(0, buffer.position());
Assert.assertEquals(2048, buffer.limit());
Assert.assertEquals(2048, buffer.capacity());
buffer = allocator.allocate(0);
Assert.assertTrue(buffer.isDirect());
Assert.assertEquals(0, buffer.position());
Assert.assertEquals(0, buffer.limit());
Assert.assertEquals(0, buffer.capacity());
}
@Test
public void testHeapByteBufferAllocator() {
final HeapByteBufferAllocator allocator = new HeapByteBufferAllocator();
ByteBuffer buffer = allocator.allocate(1);
Assert.assertNotNull(buffer);
Assert.assertFalse(buffer.isDirect());
Assert.assertEquals(0, buffer.position());
Assert.assertEquals(1, buffer.limit());
Assert.assertEquals(1, buffer.capacity());
buffer = allocator.allocate(2048);
Assert.assertFalse(buffer.isDirect());
Assert.assertEquals(0, buffer.position());
Assert.assertEquals(2048, buffer.limit());
Assert.assertEquals(2048, buffer.capacity());
buffer = allocator.allocate(0);
Assert.assertFalse(buffer.isDirect());
Assert.assertEquals(0, buffer.position());
Assert.assertEquals(0, buffer.limit());
Assert.assertEquals(0, buffer.capacity());
}
}