buffertest.java

nio的framework,不需要关注NIO编程的细节,只需要根据几个简单的API就可以使用NIO了.

/*
 * Copyright 2004-2006 the original author or authors.
 *
 * Licensed 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.
 */
package net.sf.cindy.buffer;

import java.io.ByteArrayInputStream;
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 java.util.Arrays;
import java.util.Random;

import junit.framework.TestCase;
import net.sf.cindy.Buffer;
import net.sf.cindy.util.Charset;

/**
 * @author <a href="[e-mail]">Roger Chen</a>
 * @version $id$
 */
public abstract class BufferTest extends TestCase {

    protected final Random random = new Random();

    protected abstract Buffer newBuffer(int capacity);

    public void testCreate() {
        for (int i = 0; i < 5; i++) {
            int capacity = random.nextInt(1000) + 1;
            Buffer buffer = newBuffer(capacity);
            assertEquals(0, buffer.position());
            assertEquals(capacity, buffer.limit());
            assertEquals(capacity, buffer.capacity());
            assertEquals(capacity, buffer.remaining());
            assertTrue(buffer.hasRemaining());
        }
    }

    public void testRelease() {
        Buffer buffer = newBuffer(10);
        assertFalse(buffer.isReleased());
        buffer.get();

        Buffer slice = buffer.slice();
        assertFalse(slice.isReleased());
        slice.get();

        Buffer duplicate = buffer.duplicate();
        assertFalse(duplicate.isReleased());
        duplicate.get();

        buffer.release();
        assertTrue(buffer.isReleased());
        assertTrue(slice.isReleased());
        assertTrue(duplicate.isReleased());
        try {
            buffer.get();
            fail();
        } catch (ReleasedBufferException e) {
        }
        try {
            slice.get();
            fail();
        } catch (ReleasedBufferException e) {
        }
        try {
            duplicate.get();
            fail();
        } catch (ReleasedBufferException e) {
        }

        buffer = newBuffer(10);
        buffer.setPermanent(true);
        buffer.release();
        assertFalse(buffer.isReleased());
        buffer.get();
    }

    public void testEquals() {
        Buffer buffer1 = newBuffer(256);
        Buffer buffer2 = newBuffer(256);
        for (int i = 0; i < 256; i++) {
            buffer1.put((byte) i);
            buffer2.put((byte) i);
        }
        assertEquals(buffer1, buffer2);
        buffer1.flip();
        assertFalse(buffer1.equals(buffer2));
        buffer2.flip();
        assertEquals(buffer1, buffer2);
    }

    public void testAsByteBuffer() {
        Buffer buffer = newBuffer(256);
        for (int i = 0; i < 256; i++) {
            buffer.put((byte) i);
        }

        buffer.clear();
        ByteBuffer b1 = buffer.asByteBuffer();
        assertEquals(buffer.position(), b1.position());
        assertEquals(buffer.limit(), b1.limit());
        assertEquals(buffer.capacity(), b1.capacity());
        while (b1.hasRemaining())
            assertEquals(b1.get(), buffer.get());

        buffer.clear();
        buffer.limit(random.nextInt(buffer.capacity()));
        buffer.position(random.nextInt(buffer.limit()));
        ByteBuffer b2 = buffer.asByteBuffer();
        assertEquals(buffer.position(), b2.position());
        assertEquals(buffer.limit(), b2.limit());
        assertEquals(buffer.capacity(), b2.capacity());
        while (b2.hasRemaining())
            assertEquals(b2.get(), buffer.get());

        buffer.clear();
        buffer.limit(random.nextInt(buffer.capacity()));
        buffer.position(random.nextInt(buffer.limit()));
        buffer = buffer.slice();
        ByteBuffer b3 = buffer.asByteBuffer();
        assertEquals(buffer.position(), b3.position());
        assertEquals(buffer.limit(), b3.limit());
        assertEquals(buffer.capacity(), b3.capacity());
        while (b3.hasRemaining())
            assertEquals(b3.get(), buffer.get());
    }

    public void testWrite() {
        byte[] b = new byte[random.nextInt(5000)];

        Buffer buffer = newBuffer(b.length);
        buffer.put(b);
        buffer.flip();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        WritableByteChannel channel = Channels.newChannel(baos);

        try {
            int writeCount = 0;
            while (true) {
                if (!buffer.hasRemaining())
                    break;
                int n = buffer.write(channel);
                if (n == -1)
                    break;
                writeCount += n;
            }
            assertEquals(b.length, writeCount);
            assertTrue(Arrays.equals(baos.toByteArray(), b));
        } catch (IOException e) {
            fail(e.toString());
        }
    }

    public void testRead() {
        byte[] b = new byte[random.nextInt(5000)];
        Buffer buffer = newBuffer(b.length);

        ByteArrayInputStream bais = new ByteArrayInputStream(b);
        ReadableByteChannel channel = Channels.newChannel(bais);

        try {
            int readCount = 0;
            while (true) {
                if (!buffer.hasRemaining())
                    break;
                int n = buffer.read(channel);
                if (n == -1)
                    break;
                readCount += n;
            }
            assertEquals(b.length, readCount);
            assertEquals(buffer.position(), b.length);
            buffer.flip();

            int i = 0;
            while (buffer.hasRemaining()) {
                assertEquals(buffer.get(), b[i++]);
            }
        } catch (IOException e) {
            fail(e.toString());
        }
    }

    public void testSkip() {
        Buffer buffer = newBuffer(random.nextInt(100) + 10);
        buffer.skip(1);
        assertEquals(buffer.position(), 1);
        buffer.skip(2);
        assertEquals(buffer.position(), 3);
        buffer.skip(buffer.remaining());
        assertEquals(buffer.position(), buffer.limit());
    }

    public void testIndexOf() {
        Buffer buffer = newBuffer(256);
        for (int i = 0; i < 256; i++) {
            buffer.put((byte) i);
        }
        buffer.flip();

        // Test length 0
        byte[] pattern = new byte[0];
        assertEquals(0, buffer.indexOf(pattern));

        // Test length 1
        pattern = new byte[1];
        for (int i = 0; i < 10; i++) {
            random.nextBytes(pattern);
            assertEquals((int) (pattern[0] & 0xff), buffer.indexOf(pattern));
        }

        // Test length n
        for (int i = 0; i < 10; i++) {
            int pos = random.nextInt(250);
            pattern = new byte[5];
            for (int j = 0; j < pattern.length; j++) {
                pattern[j] = (byte) (pos + j);
            }
            assertEquals(pos, buffer.indexOf(pattern));
        }

        // Test wrong
        pattern = new byte[2];
        byte b = (byte) random.nextInt(256);
        pattern[0] = b;