streamwritefiltertest.java

apache 的一个socket框架

/*
 *  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.
 *
 */
package org.apache.mina.filter;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.security.MessageDigest;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

import junit.framework.TestCase;
import org.apache.mina.common.ByteBuffer;
import org.apache.mina.common.IdleStatus;
import org.apache.mina.common.IoAcceptor;
import org.apache.mina.common.IoConnector;
import org.apache.mina.common.IoFilter.NextFilter;
import org.apache.mina.common.IoFilter.WriteRequest;
import org.apache.mina.common.IoFutureListener;
import org.apache.mina.common.IoHandlerAdapter;
import org.apache.mina.common.IoSession;
import org.apache.mina.common.WriteFuture;
import org.apache.mina.common.support.DefaultWriteFuture;
import org.apache.mina.transport.socket.nio.SocketAcceptor;
import org.apache.mina.transport.socket.nio.SocketAcceptorConfig;
import org.apache.mina.transport.socket.nio.SocketConnector;
import org.apache.mina.util.AvailablePortFinder;
import org.easymock.AbstractMatcher;
import org.easymock.MockControl;

/**
 * Tests {@link StreamWriteFilter}.
 *
 * @author The Apache Directory Project ([e-mail])
 * @version $Rev$, $Date$
 */
public class StreamWriteFilterTest extends TestCase {
    MockControl mockSession;

    MockControl mockNextFilter;

    IoSession session;

    NextFilter nextFilter;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        /*
         * Create the mocks.
         */
        mockSession = MockControl.createControl(IoSession.class);
        mockNextFilter = MockControl.createControl(NextFilter.class);
        session = (IoSession) mockSession.getMock();
        nextFilter = (NextFilter) mockNextFilter.getMock();

        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(null);
    }

    public void testWriteEmptyStream() throws Exception {
        StreamWriteFilter filter = new StreamWriteFilter();

        InputStream stream = new ByteArrayInputStream(new byte[0]);
        WriteRequest writeRequest = new WriteRequest(stream,
                new DummyWriteFuture());

        /*
         * Record expectations
         */
        nextFilter.messageSent(session, stream);

        /*
         * Replay.
         */
        mockNextFilter.replay();
        mockSession.replay();

        filter.filterWrite(nextFilter, session, writeRequest);

        /*
         * Verify.
         */
        mockNextFilter.verify();
        mockSession.verify();

        assertTrue(writeRequest.getFuture().isWritten());
    }

    /**
     * Tests that the filter just passes objects which aren't InputStreams
     * through to the next filter.
     */
    public void testWriteNonStreamMessage() throws Exception {
        StreamWriteFilter filter = new StreamWriteFilter();

        Object message = new Object();
        WriteRequest writeRequest = new WriteRequest(message,
                new DummyWriteFuture());

        /*
         * Record expectations
         */
        nextFilter.filterWrite(session, writeRequest);
        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(null);
        nextFilter.messageSent(session, message);

        /*
         * Replay.
         */
        mockNextFilter.replay();
        mockSession.replay();

        filter.filterWrite(nextFilter, session, writeRequest);
        filter.messageSent(nextFilter, session, message);

        /*
         * Verify.
         */
        mockNextFilter.verify();
        mockSession.verify();
    }

    /**
     * Tests when the contents of the stream fits into one write buffer.
     */
    public void testWriteSingleBufferStream() throws Exception {
        StreamWriteFilter filter = new StreamWriteFilter();

        byte[] data = new byte[] { 1, 2, 3, 4 };

        InputStream stream = new ByteArrayInputStream(data);
        WriteRequest writeRequest = new WriteRequest(stream,
                new DummyWriteFuture());

        /*
         * Record expectations
         */
        session.setAttribute(StreamWriteFilter.CURRENT_STREAM, stream);
        mockSession.setReturnValue(null);
        session.setAttribute(StreamWriteFilter.INITIAL_WRITE_FUTURE,
                writeRequest.getFuture());
        mockSession.setReturnValue(null);
        nextFilter
                .filterWrite(session, new WriteRequest(ByteBuffer.wrap(data)));
        mockNextFilter.setMatcher(new WriteRequestMatcher());

        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        session.removeAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        session.removeAttribute(StreamWriteFilter.INITIAL_WRITE_FUTURE);
        mockSession.setReturnValue(writeRequest.getFuture());
        session.removeAttribute(StreamWriteFilter.WRITE_REQUEST_QUEUE);
        mockSession.setReturnValue(null);
        nextFilter.messageSent(session, stream);

        /*
         * Replay.
         */
        mockNextFilter.replay();
        mockSession.replay();

        filter.filterWrite(nextFilter, session, writeRequest);
        filter.messageSent(nextFilter, session, data);

        /*
         * Verify.
         */
        mockNextFilter.verify();
        mockSession.verify();

        assertTrue(writeRequest.getFuture().isWritten());
    }

    /**
     * Tests when the contents of the stream doesn't fit into one write buffer.
     */
    public void testWriteSeveralBuffersStream() throws Exception {
        StreamWriteFilter filter = new StreamWriteFilter();
        filter.setWriteBufferSize(4);

        byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        byte[] chunk1 = new byte[] { 1, 2, 3, 4 };
        byte[] chunk2 = new byte[] { 5, 6, 7, 8 };
        byte[] chunk3 = new byte[] { 9, 10 };

        InputStream stream = new ByteArrayInputStream(data);
        WriteRequest writeRequest = new WriteRequest(stream,
                new DummyWriteFuture());

        /*
         * Record expectations
         */
        session.setAttribute(StreamWriteFilter.CURRENT_STREAM, stream);
        mockSession.setReturnValue(null);
        session.setAttribute(StreamWriteFilter.INITIAL_WRITE_FUTURE,
                writeRequest.getFuture());
        mockSession.setReturnValue(null);
        nextFilter.filterWrite(session, new WriteRequest(ByteBuffer
                .wrap(chunk1)));
        mockNextFilter.setMatcher(new WriteRequestMatcher());

        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        nextFilter.filterWrite(session, new WriteRequest(ByteBuffer
                .wrap(chunk2)));

        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        nextFilter.filterWrite(session, new WriteRequest(ByteBuffer
                .wrap(chunk3)));

        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        session.removeAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        session.removeAttribute(StreamWriteFilter.INITIAL_WRITE_FUTURE);
        mockSession.setReturnValue(writeRequest.getFuture());
        session.removeAttribute(StreamWriteFilter.WRITE_REQUEST_QUEUE);
        mockSession.setReturnValue(null);
        nextFilter.messageSent(session, stream);

        /*
         * Replay.
         */
        mockNextFilter.replay();
        mockSession.replay();

        filter.filterWrite(nextFilter, session, writeRequest);
        filter.messageSent(nextFilter, session, chunk1);
        filter.messageSent(nextFilter, session, chunk2);
        filter.messageSent(nextFilter, session, chunk3);

        /*
         * Verify.
         */
        mockNextFilter.verify();
        mockSession.verify();

        assertTrue(writeRequest.getFuture().isWritten());
    }

    public void testWriteWhileWriteInProgress() throws Exception {
        StreamWriteFilter filter = new StreamWriteFilter();

        Queue<? extends Object> queue = new LinkedList<Object>();
        InputStream stream = new ByteArrayInputStream(new byte[5]);

        /*
         * Record expectations
         */
        mockSession.reset();
        session.getAttribute(StreamWriteFilter.CURRENT_STREAM);
        mockSession.setReturnValue(stream);
        session.getAttribute(StreamWriteFilter.WRITE_REQUEST_QUEUE);
        mockSession.setReturnValue(queue);

        /*
         * Replay.
         */
        mockNextFilter.replay();
        mockSession.replay();

        WriteRequest wr = new WriteRequest(new Object(), new DummyWriteFuture());
        filter.filterWrite(nextFilter, session, wr);
        assertEquals(1, queue.size());
        assertSame(wr, queue.poll());

        /*
         * Verify.
         */
        mockNextFilter.verify();
        mockSession.verify();
    }

    public void testWritesWriteRequestQueueWhenFinished() throws Exception {
        StreamWriteFilter filter = new StreamWriteFilter();

        WriteRequest wrs[] = new WriteRequest[] {
                new WriteRequest(new Object(), new DummyWriteFuture()),
                new WriteRequest(new Object(), new DummyWriteFuture()),
                new WriteRequest(new Object(), new DummyWriteFuture()) };
        Queue<WriteRequest> queue = new LinkedList<WriteRequest>();
        queue.add(wrs[0]);
        queue.add(wrs[1]);
        queue.add(wrs[2]);
        InputStream stream = new ByteArrayInputStream(new byte[0]);