connectioncontrollertest.java

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

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

    public void testEmptyReservations() {
        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();

        assertNull(reservations.queryByConnectionName("foo://bar"));
        assertTrue(reservations.queryBySuiteID(13).isEmpty());
        assertTrue(reservations.getAllReservations().isEmpty());
    }

    public void testAddAndRemove() 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);
        reservations.remove(h);

        assertNull(reservations.queryByConnectionName(connection));
        assertTrue(reservations.queryBySuiteID(midletSuiteId).isEmpty());
        assertTrue(reservations.getAllReservations().isEmpty());
    }

    public void testTwoHandlersReservations() throws IOException {
        final int midletSuiteId1 = 123;
        final String midlet1 = "com.sun.Foo";
        final String connection1 = "foo://bar";
        final String filter1 = "*.123";

        final ConnectionController.ReservationHandler h1 =
                createFakeReservationHandler(
                    midletSuiteId1, midlet1, connection1, filter1);

        final int midletSuiteId2 = 321;
        final String midlet2 = "com.sun.Bar";
        final String connection2 = "qux://bar";
        final String filter2 = "*";

        final ConnectionController.ReservationHandler h2 =
                createFakeReservationHandler(
                    midletSuiteId2, midlet2, connection2, filter2);

        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();
        reservations.add(h1);
        reservations.add(h2);

        assertSame(h1, reservations.queryByConnectionName(connection1));
        assertSame(h2, reservations.queryByConnectionName(connection2));
        checkCollectionHasSingleHandler(
                reservations.queryBySuiteID(midletSuiteId1), h1);
        checkCollectionHasSingleHandler(
                reservations.queryBySuiteID(midletSuiteId2), h2);
        assertSetsEqual(new Object [] {h1, h2},
			reservations.getAllReservations());
    }

    public void testClear() throws IOException {
        final int midletSuiteId1 = 123;
        final String midlet1 = "com.sun.Foo";
        final String connection1 = "foo://bar";
        final String filter1 = "*.123";

        final ConnectionController.ReservationHandler h1 =
                createFakeReservationHandler(
                    midletSuiteId1, midlet1, connection1, filter1);

        final int midletSuiteId2 = 321;
        final String midlet2 = "com.sun.Bar";
        final String connection2 = "qux://bar";
        final String filter2 = "*";

        final ConnectionController.ReservationHandler h2 =
                createFakeReservationHandler(
                    midletSuiteId2, midlet2, connection2, filter2);

        final ConnectionController.Reservations reservations =
                new ConnectionController.Reservations();
        reservations.add(h1);
        reservations.add(h2);
        reservations.clear();

        assertNull(reservations.queryByConnectionName(connection1));
        assertNull(reservations.queryByConnectionName(connection2));
        assertTrue(reservations.queryBySuiteID(midletSuiteId1).isEmpty());
        assertTrue(reservations.queryBySuiteID(midletSuiteId2).isEmpty());
        assertTrue(reservations.getAllReservations().isEmpty());
    }

    private void checkStoreEmpty(final Store store) {
        store.listConnections(new Store.ConnectionsConsumer() {
            public void consume(
                    final int id, final ConnectionInfo [] infos) {
                fail("store must be empty");
            }
        });
    }

    private void checkStoreHasSingleRecord(
            final Store store,
            final int midletSuiteId, final String midlet,
            final String connection, final String filter) {
        final ConnectionInfo info =
                new ConnectionInfo(connection, midlet, filter);

        store.listConnections(new Store.ConnectionsConsumer() {
            public void consume(
                    final int id, final ConnectionInfo [] infos) {
                assertEquals(id, midletSuiteId);
                assertEquals(1, infos.length);
                assertEquals(info, infos[0]);
            }
        });
    }

    private void checkSingletonConnectionList(
            final ConnectionController cc,
            final int midletSuiteId,
            final String connection) {
        final String [] cns = cc.listConnections(midletSuiteId, false);
        assertEquals(1, cns.length);
        assertEquals(connection, cns[0]);
    }

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

        final Store store = createStore();

        final MockReservationDescriptor descriptor =
                new MockReservationDescriptor(connection, filter);

        final ConnectionController cc = createConnectionController(store);

        cc.registerConnection(midletSuiteId, midlet, descriptor);

        assertTrue(descriptor.isReserved);
        assertFalse(descriptor.connectionReservation.isCancelled);
        checkStoreHasSingleRecord(store,
                midletSuiteId, midlet, connection, filter);
        checkSingletonConnectionList(cc, midletSuiteId, connection);
        assertEquals(midlet, cc.getMIDlet(midletSuiteId, connection));
        assertEquals(filter, cc.getFilter(midletSuiteId, connection));
    }

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

        final String filter2 = "*.*.*";

        final Store store = createStore();

        final MockReservationDescriptor descriptor1 =
                new MockReservationDescriptor(connection, filter);

        final MockReservationDescriptor descriptor2 =
                new MockReservationDescriptor(connection, filter2);

        final ConnectionController cc = createConnectionController(store);

        cc.registerConnection(midletSuiteId, midlet, descriptor1);
        cc.registerConnection(midletSuiteId, midlet, descriptor2);

        assertTrue(descriptor1.isReserved);
        assertTrue(descriptor1.connectionReservation.isCancelled);
        assertTrue(descriptor2.isReserved);
        assertFalse(descriptor2.connectionReservation.isCancelled);

        checkStoreHasSingleRecord(store,
                midletSuiteId, midlet, connection, filter2);
        checkSingletonConnectionList(cc, midletSuiteId, connection);
        assertEquals(midlet, cc.getMIDlet(midletSuiteId, connection));
        assertEquals(filter2, cc.getFilter(midletSuiteId, connection));
    }

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

        final int midletSuiteId2 = midletSuiteId + 17;

        final Store store = createStore();

        final MockReservationDescriptor descriptor1 =
                new MockReservationDescriptor(connection, filter);

        final MockReservationDescriptor descriptor2 =
                new MockReservationDescriptor(connection, filter);

        final ConnectionController cc = createConnectionController(store);

        cc.registerConnection(midletSuiteId, midlet, descriptor1);

        boolean ioExceptionThrown = false;
        try {
            cc.registerConnection(midletSuiteId2, midlet, descriptor2);
        } catch (IOException ioex) {
            ioExceptionThrown = true;
        }

        assertTrue(ioExceptionThrown);

        assertTrue(descriptor1.isReserved);
        assertFalse(descriptor1.connectionReservation.isCancelled);

        assertFalse(descriptor2.isReserved);

        checkStoreHasSingleRecord(store,
                midletSuiteId, midlet, connection, filter);

        checkSingletonConnectionList(cc, midletSuiteId, connection);
        assertEquals(midlet, cc.getMIDlet(midletSuiteId, connection));
        assertEquals(filter, cc.getFilter(midletSuiteId, connection));

        assertEquals(0, cc.listConnections(midletSuiteId2, false).length);
        assertNull(cc.getMIDlet(midletSuiteId2, connection));
        assertNull(cc.getFilter(midletSuiteId2, connection));
    }

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

        final String midlet2 = "com.sun.Bar";

        final Store store = createStore();

        final MockReservationDescriptor descriptor1 =
                new MockReservationDescriptor(connection, filter);

        final MockReservationDescriptor descriptor2 =
                new MockReservationDescriptor(connection, filter);

        final ConnectionController cc = createConnectionController(store);

        cc.registerConnection(midletSuiteId, midlet, descriptor1);
        cc.registerConnection(midletSuiteId, midlet2, descriptor2);

        assertTrue(descriptor1.isReserved);
        assertTrue(descriptor1.connectionReservation.isCancelled);

        assertTrue(descriptor2.isReserved);
        assertFalse(descriptor2.connectionReservation.isCancelled);

        checkStoreHasSingleRecord(store,
                midletSuiteId, midlet2, connection, filter);
        checkSingletonConnectionList(cc, midletSuiteId, connection);
        assertEquals(midlet2, cc.getMIDlet(midletSuiteId, connection));
        assertEquals(filter, cc.getFilter(midletSuiteId, connection));
    }

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

        final Store store = createStore();

        final ReservationDescriptor descriptor = new ReservationDescriptor() {
            public ConnectionReservation reserve(
                    final int midletSuiteId, final String midletClassName,
                    final DataAvailableListener dataAvailableListener)
                        throws IOException {
                throw new IOException("cannot be registered");
            }

            public String getConnectionName() {
                return connection;
            }

            public String getFilter() {
                return filter;
            }
        };

        final ConnectionController cc = createConnectionController(store);

        boolean ioExceptionThrown = false;
        try {
            cc.registerConnection(midletSuiteId, midlet, descriptor);
        } catch (IOException ioex) {
            ioExceptionThrown = true;
        }

        assertTrue(ioExceptionThrown);

        checkStoreEmpty(store);
        assertEquals(0, cc.listConnections(midletSuiteId, false).length);
        assertNull(cc.getMIDlet(midletSuiteId, connection));
        assertNull(cc.getFilter(midletSuiteId, connection));
    }

    public void testListConnectionsAll() throws IOException {
        final int midletSuiteId1 = 123;