connectioncontrollertest.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 1,253 行 · 第 1/4 页

/*
 * Copyright  1990-2006 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

package com.sun.midp.push.controller;

import com.sun.midp.push.reservation.impl.ReservationDescriptorFactory;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import junit.framework.*;
import com.sun.midp.push.reservation.ConnectionReservation;
import com.sun.midp.push.reservation.DataAvailableListener;
import com.sun.midp.push.reservation.ReservationDescriptor;
import com.sun.midp.push.persistence.Store;
import com.sun.midp.push.persistence.StoreUtils;
import com.sun.j2me.security.AccessControlContext;
import java.io.IOException;
import javax.microedition.io.ConnectionNotFoundException;

/*
 * ConnectionController tests.
 *
 * <p>
 * TODO: failing store tests.
 * </p>
 */
public final class ConnectionControllerTest extends TestCase {

    public ConnectionControllerTest(final String testName) {
        super(testName);
    }

    /**
     * Delayble thread.
     *
     * Instances of this class can be scheduled for executuion,
     * but actual execution can be delayed with a lock.
     */
    private static abstract class DelayableThread extends Thread {
        private final Object lock = new Object();

        abstract protected void doRun();

        public final void run() {
            synchronized (lock) {
                doRun();
            }
        }
    }

    /**
     * Mock implementation of ConnectionReservation.
     */
    private static final class MockConnectionReservation
            implements ConnectionReservation {

        private final DataAvailableListener listener;

        private boolean isCancelled = false;

        private boolean hasAvailableData_ = false;

        MockConnectionReservation(final DataAvailableListener listener) {
            this.listener = listener;
        }

        /** {@inheritDoc} */
        public boolean hasAvailableData() {
            if (isCancelled) {
                throw new IllegalStateException("cancelled reservation");
            }
            return hasAvailableData_;
        }

        /** {@inheritDoc} */
        public void cancel() {
            if (isCancelled) {
                throw new IllegalStateException("double cancellation");
            }
            isCancelled = true;
        }

        /** Returns a thread that can be used to 'ping' the connection. */
        DelayableThread pingThread() {
            return new DelayableThread() {
                protected void doRun() {
                    listener.dataAvailable();
                }
            };
        }
    }

    /**
     * Mock implementation of ReservationDescriptor.
     */
    private static final class MockReservationDescriptor
            implements ReservationDescriptor {
        /** connection name. */
        final String connectionName;

        /** filter. */
        final String filter;

        /** reserved flag. */
        boolean isReserved = false;

        /** connection reservation. */
        MockConnectionReservation connectionReservation = null;

        /**
         * Creates a mock.
         *
         * @param connectionName connection name
         * (cannot be <code>null</code>)
         *
         * @param filter filter
         * (cannot be <code>null</code>)
         */
        MockReservationDescriptor(final String connectionName,
                final String filter) {
            this.connectionName = connectionName;
            this.filter = filter;
        }

        /** {@inheritDoc} */
        public ConnectionReservation reserve(
                final int midletSuiteId, final String midletClassName,
                final DataAvailableListener dataAvailableListener)
                    throws IOException {
            isReserved = true;
            connectionReservation =
                    new MockConnectionReservation(dataAvailableListener);
            return connectionReservation;
        }

        /** {@inheritDoc} */
        public String getConnectionName() {
            return connectionName;
        }

        /** {@inheritDoc} */
        public String getFilter() {
            return filter;
        }
    }

    private static Store createStore() throws IOException {
        return StoreUtils.getInstance().getStore();
    }

    private final ReservationDescriptorFactory rdf =
            new ReservationDescriptorFactory() {
        public ReservationDescriptor getDescriptor(
                final String connectionName, final String filter,
                final AccessControlContext context)
                    throws IllegalArgumentException,
                        ConnectionNotFoundException {
            if (context == null) {
                throw new RuntimeException("null AccessControlContext");
            }
            return new MockReservationDescriptor(connectionName, filter);
        }
    };

    private ConnectionController createConnectionController(
            final Store store, final LifecycleAdapter lifecycleAdapter) {
        /*
         * IMPL_NOTE: don't forget mock parameter verifier if the signature
         * below change
         */
        return new ConnectionController(store, rdf, lifecycleAdapter);
    }

    private ConnectionController createConnectionController(
            final Store store) {
        return createConnectionController(store, new ListingLifecycleAdapter());
    }

    private ConnectionController.ReservationHandler
        createFakeReservationHandler(
            final int midletSuiteId,
            final String midlet,
            final String connection,
            final String filter) throws IOException {
        final ReservationDescriptor descriptor =
                new MockReservationDescriptor(connection, filter);
        return createConnectionController(createStore())
                .new ReservationHandler(midletSuiteId, midlet, descriptor);
    }

    public void testReservationHandlerCtor() throws IOException {
        final int midletSuiteId = 123;
        final String midlet = "com.sun.Foo";
        final String connection = "foo://bar";
        final String filter = "*.123";

        final ConnectionController.ReservationHandler h =
                createFakeReservationHandler(
                    midletSuiteId, midlet, connection, filter);

        assertEquals(midletSuiteId, h.getSuiteId());
        assertEquals(midlet, h.getMidlet());
        assertEquals(connection, h.getConnectionName());
        assertEquals(filter, h.getFilter());
    }

    private void assertSetsEqual(
            final Object [] expected, final Collection actual) {
        assertEquals(new HashSet(Arrays.asList(expected)), new HashSet(actual));
    }

    private void assertSetsEqual(
            final Object [] expected, final Object [] actual) {
        assertSetsEqual(expected, Arrays.asList(actual));
    }

    private void checkCollectionHasSingleHandler(
            final Collection reservations,
            final ConnectionController.ReservationHandler handler) {
        assertEquals(1, reservations.size());
        assertSame(handler, reservations.iterator().next());
    }

    public void testQueryByConnection() throws IOException {
        final int midletSuiteId = 123;
        final String midlet = "com.sun.Foo";
        final String connection = "foo://bar";
        final String filter = "*.123";

        final ConnectionController.ReservationHandler h =
                createFakeReservationHandler(
                    midletSuiteId, midlet, connection, filter);

        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();
        reservations.add(h);

        assertSame(h, reservations.queryByConnectionName(connection));
        checkCollectionHasSingleHandler(reservations.getAllReservations(), h);
    }

    public void testQueryByConnectionMissing() throws IOException {
        final int midletSuiteId = 123;
        final String midlet = "com.sun.Foo";
        final String connection = "foo://bar";
        final String filter = "*.123";

        final ConnectionController.ReservationHandler h =
                createFakeReservationHandler(
                    midletSuiteId, midlet, connection, filter);

        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();
        reservations.add(h);

        assertNull(reservations.queryByConnectionName(connection + "qux"));
        checkCollectionHasSingleHandler(reservations.getAllReservations(), h);
    }

    public void testQueryBySuite() throws IOException {
        final int midletSuiteId = 123;
        final String midlet = "com.sun.Foo";
        final String connection = "foo://bar";
        final String filter = "*.123";

        final ConnectionController.ReservationHandler h =
                createFakeReservationHandler(
                    midletSuiteId, midlet, connection, filter);

        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();
        reservations.add(h);

        checkCollectionHasSingleHandler(
                reservations.queryBySuiteID(midletSuiteId), h);
        checkCollectionHasSingleHandler(reservations.getAllReservations(), h);
    }

    public void testQueryBySuiteMissing() throws IOException {
        final int midletSuiteId = 123;
        final String midlet = "com.sun.Foo";
        final String connection = "foo://bar";
        final String filter = "*.123";

        final ConnectionController.ReservationHandler h =
                createFakeReservationHandler(
                    midletSuiteId, midlet, connection, filter);

        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();
        reservations.add(h);

        assertTrue(reservations.queryBySuiteID(midletSuiteId + 1).isEmpty());