| /** |
| * 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.felix.io; |
| |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.util.Dictionary; |
| import java.util.Hashtable; |
| |
| import javax.microedition.io.Connection; |
| import javax.microedition.io.ConnectionNotFoundException; |
| |
| import junit.framework.TestCase; |
| |
| import org.mockito.ArgumentCaptor; |
| import org.mockito.Mockito; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.InvalidSyntaxException; |
| import org.osgi.framework.ServiceEvent; |
| import org.osgi.framework.ServiceListener; |
| import org.osgi.framework.ServiceReference; |
| import org.osgi.framework.ServiceRegistration; |
| import org.osgi.service.io.ConnectionFactory; |
| import org.osgi.service.io.ConnectorService; |
| |
| /** |
| * <tt>ConnectorServiceTest</tt> represents test class for {@link ConnectorService}. |
| * |
| * @version $Rev$ $Date$ |
| */ |
| public class ConnectorServiceTest extends TestCase |
| { |
| |
| private BundleContext m_bundleContext; |
| private ConnectorService m_service; |
| private ServiceListener m_serviceListener; |
| private long m_serviceId; |
| |
| private ServiceRegistration registerConnectionFactory(ConnectionFactoryMock connFactory, Dictionary props) |
| { |
| // service reference for ConnectionFactory service |
| ServiceReference reference = (ServiceReference) Mockito.mock(ServiceReference.class); |
| Mockito.when(reference.getProperty(ConnectionFactory.IO_SCHEME)).thenReturn( |
| props.get(ConnectionFactory.IO_SCHEME)); |
| Mockito.when(reference.getProperty(Constants.SERVICE_ID)).thenReturn(new Long(++m_serviceId)); |
| Mockito.when(reference.getProperty(Constants.SERVICE_RANKING)).thenReturn(props.get(Constants.SERVICE_RANKING)); |
| // service registration for ConnectionFactory service |
| ServiceRegistration registration = (ServiceRegistration) Mockito.mock(ServiceRegistration.class); |
| Mockito.when(registration.getReference()).thenReturn(reference); |
| // service event |
| ServiceEvent registeredEvent = (ServiceEvent) Mockito.mock(ServiceEvent.class); |
| Mockito.when(registeredEvent.getServiceReference()).thenReturn(reference); |
| Mockito.when(new Integer(registeredEvent.getType())).thenReturn(new Integer(ServiceEvent.REGISTERED)); |
| Mockito.when(m_bundleContext.getService(reference)).thenReturn(connFactory); |
| // sending registration event |
| // service tracker for ConnectionFactory service used by ConnectorService |
| // will be informed about service registration |
| m_serviceListener.serviceChanged(registeredEvent); |
| |
| return registration; |
| } |
| |
| private ConnectorService getConnectorService() |
| { |
| return m_service; |
| } |
| |
| public void setUp() |
| { |
| m_bundleContext = (BundleContext) Mockito.mock(BundleContext.class); |
| ArgumentCaptor argument = ArgumentCaptor.forClass(ServiceListener.class); |
| m_service = new ConnectorServiceImpl(m_bundleContext); |
| try |
| { |
| ((BundleContext) Mockito.verify(m_bundleContext)).addServiceListener((ServiceListener) argument.capture(), |
| Mockito.anyString()); |
| } catch (InvalidSyntaxException e) |
| { |
| fail(); |
| } |
| // getting from captor serviceListener which listen to ConnectionFactory service |
| m_serviceListener = (ServiceListener) argument.getValue(); |
| } |
| |
| public void tearDown() |
| { |
| |
| } |
| |
| /** |
| * Tests all methods provided by {@link ConnectorService}. |
| * |
| * @throws Exception |
| */ |
| public void testOpen() throws Exception |
| { |
| ConnectionFactoryMock connFactory = new ConnectionFactoryMock(); |
| Dictionary props = new Hashtable(); |
| props.put(ConnectionFactory.IO_SCHEME, "file"); |
| ServiceRegistration registration = registerConnectionFactory(connFactory, props); |
| ConnectorService service = getConnectorService(); |
| |
| Connection connection = service.open("file://test.txt"); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ_WRITE, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned Connection", connection); |
| |
| connection = service.open("file://test.txt", ConnectorService.READ); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned Connection", connection); |
| |
| connection = service.open("file://test.txt", ConnectorService.WRITE); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.WRITE, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned Connection", connection); |
| |
| connection = service.open("file://test.txt", ConnectorService.READ, true); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ, connFactory.getMode()); |
| assertEquals(true, connFactory.isTimeout()); |
| assertNotNull("checks returned Connection", connection); |
| |
| try |
| { |
| connection = service.open("http://test.txt", ConnectorService.READ); |
| fail("Connection shouldn't be created"); |
| } catch (ConnectionNotFoundException e) |
| { |
| // "expected" |
| } |
| |
| try |
| { |
| service.open("file.txt"); |
| fail("Illegal format of uri"); |
| } catch (IllegalArgumentException e) |
| { |
| // expected |
| } |
| |
| DataInputStream dataInStream = service.openDataInputStream("file://test.txt"); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned DataInputStream", dataInStream); |
| |
| DataOutputStream dataOutStream = service.openDataOutputStream("file://test.txt"); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.WRITE, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned DataOutputStream", dataOutStream); |
| |
| InputStream inStream = service.openInputStream("file://test.txt"); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned InputStream", inStream); |
| |
| OutputStream outStream = service.openOutputStream("file://test.txt"); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.WRITE, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned OutputStream", outStream); |
| |
| registration.unregister(); |
| } |
| |
| /** |
| * Registers two ConnectionFactory services with same IO_SCHEME. One with higher service.ranking Connector Service |
| * should pickup service with highest service.ranking. |
| * |
| * @throws Exception |
| */ |
| public void testHighestRanking() throws Exception |
| { |
| ConnectionFactoryMock connFactory = new ConnectionFactoryMock(); |
| Dictionary props = new Hashtable(); |
| props.put(ConnectionFactory.IO_SCHEME, "file"); |
| registerConnectionFactory(connFactory, props); |
| |
| ConnectionFactoryMock connFactory2 = new ConnectionFactoryMock(); |
| props.put(Constants.SERVICE_RANKING, new Integer(Integer.MAX_VALUE)); |
| registerConnectionFactory(connFactory2, props); |
| |
| ConnectorService service = getConnectorService(); |
| |
| Connection connection = service.open("file://test.txt"); |
| assertEquals("uri checks for lowest ranking service", null, connFactory.getName()); |
| assertEquals("file://test.txt", connFactory2.getName()); |
| assertEquals(ConnectorService.READ_WRITE, connFactory2.getMode()); |
| assertEquals(false, connFactory2.isTimeout()); |
| assertNotNull("Connection should be created", connection); |
| } |
| |
| /** |
| * Registers two ConnectionFactory services with same IO_SCHEME. Connector Service should pickup service with lowest |
| * service.id. |
| * |
| * @throws Exception |
| */ |
| public void testLowestServiceId() throws Exception |
| { |
| ConnectionFactoryMock connFactory = new ConnectionFactoryMock(); |
| Dictionary props = new Hashtable(); |
| props.put(ConnectionFactory.IO_SCHEME, "file"); |
| ServiceRegistration registration = registerConnectionFactory(connFactory, props); |
| |
| ConnectionFactoryMock connFactory2 = new ConnectionFactoryMock(); |
| ServiceRegistration registration2 = registerConnectionFactory(connFactory2, props); |
| |
| ConnectorService service = getConnectorService(); |
| |
| Connection connection = service.open("file://test.txt"); |
| assertEquals("uri checks for highest service.id", null, connFactory2.getName()); |
| assertEquals("uri checks for lowest service.id", "file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ_WRITE, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned Connection", connection); |
| |
| Long serviceId1 = (Long) registration.getReference().getProperty(Constants.SERVICE_ID); |
| Long serviceId2 = (Long) registration2.getReference().getProperty(Constants.SERVICE_ID); |
| |
| assertTrue(serviceId1.longValue() < serviceId2.longValue()); |
| |
| registration.unregister(); |
| registration2.unregister(); |
| } |
| |
| /** |
| * Tests ConnectionFactory service which support 3 different schemes. |
| * |
| * @throws Exception |
| */ |
| public void testMultipleScheme() throws Exception |
| { |
| ConnectionFactoryMock connFactory = new ConnectionFactoryMock(); |
| Dictionary props = new Hashtable(); |
| props.put(ConnectionFactory.IO_SCHEME, new String[] |
| { "file", "http", "sms" }); |
| ServiceRegistration registration = registerConnectionFactory(connFactory, props); |
| ConnectorService service = getConnectorService(); |
| |
| Connection connection = service.open("file://test.txt"); |
| assertEquals("file://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ_WRITE, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned connection", connection); |
| |
| connection = service.open("http://test.txt", ConnectorService.READ); |
| assertEquals("http://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned connection", connection); |
| |
| connection = service.open("sms://test.txt", ConnectorService.READ); |
| assertEquals("sms://test.txt", connFactory.getName()); |
| assertEquals(ConnectorService.READ, connFactory.getMode()); |
| assertEquals(false, connFactory.isTimeout()); |
| assertNotNull("checks returned connection", connection); |
| |
| try |
| { |
| connection = service.open("ftp://test.txt", ConnectorService.READ); |
| fail("Connection shouldn't be created"); |
| } catch (ConnectionNotFoundException e) |
| { |
| // "expected" |
| } |
| |
| registration.unregister(); |
| } |
| |
| } |