| /* |
| * 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.das; |
| |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.Dictionary; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| import junit.framework.Assert; |
| |
| import org.apache.felix.das.util.DriverLoader; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Ignore; |
| import org.junit.Test; |
| import org.mockito.Mock; |
| import org.mockito.Mockito; |
| import org.mockito.MockitoAnnotations; |
| import org.mockito.invocation.InvocationOnMock; |
| import org.mockito.stubbing.Answer; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.BundleException; |
| import org.osgi.framework.ServiceReference; |
| import org.osgi.service.device.Constants; |
| import org.osgi.service.device.Device; |
| import org.osgi.service.device.Driver; |
| import org.osgi.service.device.DriverLocator; |
| import org.osgi.service.device.DriverSelector; |
| import org.osgi.service.device.Match; |
| import org.osgi.service.log.LogService; |
| |
| |
| |
| /** |
| * Test the actual implementation. |
| * |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> |
| */ |
| public class DeviceManagerTest |
| { |
| |
| @Mock |
| private DeviceManager m_manager; |
| |
| @Mock Bundle m_systemBundle; |
| |
| @Mock |
| private LogService m_log; |
| |
| |
| private BundleContext m_context; |
| |
| |
| private OSGiMock m_osgi; |
| |
| |
| @Before |
| public void setUp() throws Exception |
| { |
| m_osgi = new OSGiMock(); |
| |
| MockitoAnnotations.initMocks(this); |
| |
| m_context = m_osgi.getBundleContext(); |
| |
| m_manager = new DeviceManager( m_context ); |
| |
| Utils.invoke( m_manager, "init" ); |
| |
| Utils.inject( m_manager, LogService.class, m_log ); |
| |
| Mockito.when( m_context.getBundle( 0 ) ).thenReturn( m_systemBundle ); |
| |
| final CountDownLatch latch = new CountDownLatch( 1 ); |
| |
| Answer<Integer> answer = new Answer<Integer>() |
| { |
| public Integer answer(InvocationOnMock invocation) throws Throwable |
| { |
| latch.countDown(); |
| return Bundle.ACTIVE; |
| } |
| }; |
| |
| Mockito.when( m_systemBundle.getState() ).thenAnswer( answer ); |
| |
| Utils.invoke( m_manager, "start" ); |
| latch.await( 5, TimeUnit.SECONDS ); |
| |
| Mockito.when( m_context.installBundle(Mockito.isA( String.class ), ( InputStream ) Mockito.isNull() ) ) |
| .thenThrow(new NullPointerException( "inputstream is null exception" ) ); |
| } |
| |
| |
| @After |
| public void tearDown() throws Exception |
| { |
| Utils.invoke( m_manager, "stop" ); |
| Utils.invoke( m_manager, "destroy" ); |
| } |
| |
| private Driver tstCreateDriver( String driverId, int match ) throws Exception |
| { |
| Properties p = new Properties(); |
| p.put( Constants.DRIVER_ID, driverId ); |
| p.put( "match", Integer.toString( match ) ); |
| |
| return tstCreateDriver( p ); |
| } |
| |
| |
| private Driver tstCreateDriver( Properties p ) throws Exception |
| { |
| Driver driver = Mockito.mock( Driver.class ); |
| |
| ServiceReference ref = m_osgi.registerService( |
| new String[]{ Driver.class.getName() }, driver, p ); |
| |
| MatchAnswer answer = new MatchAnswer( ref ); |
| |
| Mockito.when( driver.match( Mockito.isA( ServiceReference.class ) ) ) |
| .thenAnswer( answer ); |
| |
| Bundle bundle = m_osgi.getBundle( ref ); |
| Mockito.when( bundle.getLocation() ) |
| .thenReturn( |
| DriverLoader.DRIVER_LOCATION_PREFIX + p.getProperty( Constants.DRIVER_ID )); |
| |
| return driver; |
| } |
| |
| |
| private Device tstCreateDevice( String[] cat ) |
| { |
| return tstCreateDevice( cat, true ); |
| } |
| |
| |
| private Device tstCreateDevice( String[] cat, boolean isDevice ) |
| { |
| Properties p = new Properties(); |
| p.put( Constants.DEVICE_CATEGORY, cat ); |
| if ( isDevice ) |
| { |
| return ( Device ) tstCreateService( p, Device.class ); |
| } |
| return tstCreateService( p, Object.class ); |
| } |
| |
| |
| @SuppressWarnings("unchecked") |
| private <T> T tstCreateService( Properties p, Class<?> iface ) |
| { |
| T svc = ( T ) Mockito.mock( iface, iface.getSimpleName() ); |
| |
| m_osgi.registerService( new String[] |
| { iface.getName() }, svc, p ); |
| return svc; |
| } |
| |
| |
| /** |
| * |
| * prepared all expected behavior for the installation of a dynamic driver |
| * bundle based on an acquired InputStream. |
| * |
| * |
| * @param driverId |
| * @param match |
| * @param in |
| * @return |
| * @throws BundleException |
| * @throws Exception |
| */ |
| private Driver tstExpectInstallDriverBundle( String driverId, int match, InputStream in ) throws BundleException, |
| Exception |
| { |
| |
| Bundle bundle = Mockito.mock( Bundle.class, "driverBundle" ); |
| Mockito.when( m_context.installBundle( |
| Mockito.eq( "_DD_" + driverId ), Mockito.eq( in ) ) ) |
| .thenReturn( bundle ); |
| |
| final Driver driver = tstCreateDriver( driverId, match ); |
| final ServiceReference driverRef = m_osgi.getReference( driver ); |
| |
| Answer<Object> answer = new Answer<Object>() |
| { |
| |
| public Object answer(InvocationOnMock invocation) throws Throwable |
| { |
| m_manager.driverAdded( driverRef, driver ); |
| return null; |
| } |
| }; |
| |
| //bundle start leads to the addition of the driver to |
| //the device manager. |
| Mockito.doAnswer(answer).when(bundle).start(); |
| |
| Mockito.when( bundle.getRegisteredServices() ) |
| .thenReturn( new ServiceReference[]{ driverRef } ); |
| |
| return driver; |
| } |
| |
| |
| /** |
| * returns a CountDownLatch. |
| * This countdown latch will count down as soon as <code>Device.noDriverFound()</code> |
| * has been called. |
| * @param device the Device |
| * @return the countdown latch |
| */ |
| private CountDownLatch tstExpectNoDriverFound( Device device ) |
| { |
| final CountDownLatch latch = new CountDownLatch( 1 ); |
| |
| //countdown when noDriverFound is called |
| Answer<Object> answer = new Answer<Object>() |
| { |
| public Object answer(InvocationOnMock invocation) throws Throwable |
| { |
| latch.countDown(); |
| return null; |
| } |
| }; |
| |
| Mockito.doAnswer( answer ).when(device).noDriverFound(); |
| |
| return latch; |
| |
| } |
| |
| |
| private CountDownLatch tstExpectAttach( Driver driver, Object device ) throws Exception |
| { |
| final CountDownLatch latch = new CountDownLatch( 1 ); |
| Answer<String> answer = new Answer<String>() |
| { |
| public String answer(InvocationOnMock invocation) throws Throwable |
| { |
| latch.countDown(); |
| return null; |
| } |
| }; |
| |
| //successful attach |
| Mockito.when( driver.attach( m_osgi.getReference( device ) ) ) |
| .thenAnswer( answer ); |
| |
| return latch; |
| } |
| |
| private CountDownLatch tstExpectUnloadDriverBundle( Driver driver ) throws BundleException { |
| |
| |
| final CountDownLatch latch = new CountDownLatch( 1 ); |
| Answer<String> answer = new Answer<String>() |
| { |
| public String answer(InvocationOnMock invocation) throws Throwable |
| { |
| latch.countDown(); |
| return null; |
| } |
| }; |
| |
| Bundle bundle = m_osgi.getBundle( m_osgi.getReference( driver ) ); |
| |
| Mockito.doAnswer(answer).when( bundle ).uninstall(); |
| |
| return latch; |
| } |
| |
| /** |
| * This method generates behavior on the provided DriverLocator. |
| * |
| * The given driver Ids and their matches are expected as drivers found |
| * by this driver locator. |
| * Also, if a driver is found, we can also expect that loadDriver is called; |
| * resulting in an InputStream. That particular input stream should, when installed |
| * using a bundle context, lead to the registration of a driver with |
| * the correcsponding driver id. |
| * |
| * @param locator |
| * @param driverIds |
| * @param matches |
| * @return |
| * @throws Exception |
| */ |
| private Map<String, Driver> tstExpectDriverLocatorFor( final DriverLocator locator, final String[] driverIds, |
| int[] matches ) throws Exception |
| { |
| |
| Mockito.when( locator.findDrivers( Mockito.isA( Dictionary.class ) ) ) |
| .thenReturn( driverIds ); |
| |
| Map<String, Driver> drivers = new HashMap<String, Driver>(); |
| |
| final Map<String, InputStream> streams = new HashMap<String, InputStream>(); |
| |
| for ( String driverId : driverIds ) |
| { |
| InputStream in = Mockito.mock(InputStream.class, "[InputStream for: " + driverId + "]"); |
| streams.put( driverId, in ); |
| } |
| |
| Answer<InputStream> answer = new Answer<InputStream>() |
| { |
| public InputStream answer(InvocationOnMock invocation) throws Throwable |
| { |
| final String id = invocation.getArguments()[0].toString(); |
| |
| for ( String driverId : driverIds ) |
| { |
| if ( id.equals( driverId ) ) |
| { |
| return streams.get( id ); |
| } |
| } |
| throw new IOException( "no such driverId defined in this locator: " + locator ); |
| } |
| }; |
| |
| |
| Mockito.when( locator.loadDriver( Mockito.isA( String.class ) ) ) |
| .thenAnswer( answer ); |
| |
| int i = 0; |
| for ( String driverId : driverIds ) |
| { |
| Driver driver = tstExpectInstallDriverBundle( driverId, matches[i], streams.get( driverId ) ); |
| drivers.put( driverId, driver ); |
| i++; |
| } |
| |
| return drivers; |
| |
| } |
| |
| |
| /** |
| * does not really test anything special, but ensures that the internal |
| * structure is able to parse the addition |
| */ |
| @Test |
| public void LocatorAdded() |
| { |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class ); |
| m_manager.locatorAdded( locator ); |
| |
| } |
| |
| |
| /** |
| * does not really test anything special, but ensures that the internal |
| * structure is able to parse the addition/ removal |
| */ |
| @Test |
| public void LocatorRemoved() |
| { |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class ); |
| |
| m_manager.locatorAdded( locator ); |
| m_manager.locatorRemoved( locator ); |
| |
| } |
| |
| |
| /** |
| * does not really test anything special, but ensures that the internal |
| * structure is able to parse the addition |
| * @throws Exception |
| */ |
| @Test |
| public void DriverAdded() throws Exception |
| { |
| |
| Driver driver = tstCreateDriver( "org.apache.felix.driver-1.0", 1 ); |
| |
| m_manager.driverAdded( m_osgi.getReference( driver ), driver ); |
| |
| } |
| |
| |
| /** |
| * does not really test anything special, but ensures that the internal |
| * structure is able to parse the addition/ removal |
| * @throws Exception |
| */ |
| @Test |
| public void DriverRemoved() throws Exception |
| { |
| |
| Driver driver = tstCreateDriver( "org.apache.felix.driver-1.0", 1 ); |
| |
| ServiceReference ref = m_osgi.getReference( driver ); |
| |
| m_manager.driverAdded( ref, driver ); |
| m_manager.driverRemoved( ref ); |
| } |
| |
| /** |
| * does not really test anything special, but ensures that the internal |
| * structure is able to parse the addition/ removal |
| * @throws Exception |
| */ |
| @Test |
| public void DeviceRemoved() throws Exception |
| { |
| |
| Properties p = new Properties(); |
| p.put(Constants.DEVICE_CATEGORY, new String[]{"dummy"}); |
| |
| ServiceReference ref = OSGiMock.createReference(p); |
| |
| Object device = new Object(); |
| |
| m_manager.deviceAdded( ref, device ); |
| m_manager.deviceRemoved( ref ); |
| } |
| |
| /** |
| * does not really test anything special, but ensures that the internal |
| * structure is able to parse the addition/ removal |
| * @throws Exception |
| */ |
| @Test |
| public void DeviceModified() throws Exception |
| { |
| |
| Properties p = new Properties(); |
| p.put(Constants.DEVICE_CATEGORY, new String[]{"dummy"}); |
| |
| ServiceReference ref = OSGiMock.createReference(p); |
| Object device = new Object(); |
| |
| m_manager.deviceAdded( ref, new Object() ); |
| m_manager.deviceModified(ref, device); |
| } |
| //intended flow, various configurations |
| /** |
| * We add a device, but there are no driver locators, so |
| * the noDriverFound method must be called |
| * @throws InterruptedException |
| */ |
| @Test |
| public void DeviceAddedNoDriverLocator() throws InterruptedException |
| { |
| |
| //create a mocked device |
| Device device = tstCreateDevice( new String[] |
| { "org.apache.felix" } ); |
| |
| CountDownLatch latch = tstExpectNoDriverFound( device ); |
| |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !latch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected call noDriverFound" ); |
| } |
| |
| } |
| |
| |
| /** |
| * We add a device, but there are no driver locators, however, there is a driver |
| * that matches. Thus an attach must follow. |
| * @throws Exception |
| */ |
| @Test |
| public void DeviceAddedNoDriverLocatorSuccessfulAttach() throws Exception |
| { |
| |
| Device device = tstCreateDevice( new String[] { "org.apache.felix" } ); |
| Driver driver = tstCreateDriver( "org.apache.felix.driver-1.0", 1 ); |
| |
| CountDownLatch attachLatch = tstExpectAttach( driver, device ); |
| |
| m_manager.driverAdded( m_osgi.getReference( driver ), driver ); |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !attachLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected attach" ); |
| } |
| |
| } |
| |
| |
| /** |
| * We add a device, but there are no driver locators, however, there is a driver |
| * but it sadly doesn't match. Thus a <code>noDriverFound()</code> is called. |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void DeviceAddedNoDriverLocatorAttachFails() throws Exception |
| { |
| |
| Device device = tstCreateDevice( new String[] { "org.apache.felix" } ); |
| Driver driver = tstCreateDriver( "org.apache.felix.driver-1.0", Device.MATCH_NONE ); |
| |
| CountDownLatch attachLatch = tstExpectNoDriverFound( device ); |
| |
| m_manager.driverAdded( m_osgi.getReference( driver ), driver ); |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !attachLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected attach" ); |
| } |
| |
| } |
| |
| |
| /** |
| * We add a device while there's one driverlocator that will successfully |
| * locate and load two driver bundles. We expect a <code>Driver.attach()</code> for |
| * the best matching driver. There's already a driver loaded that should not match. |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void DeviceAddedWithADriverLocator() throws Exception |
| { |
| |
| final String driverId1 = "org.apache.felix.driver-1.0"; |
| final String driverId2 = "org.apache.felix.driver-1.1"; |
| final String notMatchingButLoadedDriverId = "dotorg.apache.felix.driver-1.0"; |
| |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class ); |
| |
| Map<String, Driver> drivers = tstExpectDriverLocatorFor( locator, |
| new String[] { driverId1, driverId2 }, |
| new int[] { 30, 3 } ); |
| |
| Driver noMatcher = tstCreateDriver( notMatchingButLoadedDriverId, 100 ); |
| |
| Device device = tstCreateDevice( new String[]{ "org.apache.felix" } ); |
| |
| final CountDownLatch attachLatch = tstExpectAttach( drivers.get( driverId1 ), device ); |
| |
| final CountDownLatch unloadDriverLatch = tstExpectUnloadDriverBundle( drivers.get ( driverId2 ) ); |
| |
| m_manager.locatorAdded( locator ); |
| |
| m_manager.driverAdded( m_osgi.getReference( noMatcher ), noMatcher ); |
| |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !attachLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected an attach" ); |
| } |
| |
| //since driver1 is attached, we expect an uninstall() |
| //of all other (dynamically loaded) driver bundles |
| if ( !unloadDriverLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected an unload" ); |
| } |
| |
| } |
| |
| @Test |
| public void DeviceAddedWithADriverLocatorUnloadFails() throws Exception |
| { |
| |
| final String driverId1 = "org.apache.felix.driver-1.0"; |
| final String driverId2 = "org.apache.felix.driver-1.1"; |
| final String notMatchingButLoadedDriverId = "dotorg.apache.felix.driver-1.0"; |
| |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class ); |
| |
| Map<String, Driver> drivers = tstExpectDriverLocatorFor( locator, |
| new String[] { driverId1, driverId2 }, |
| new int[] { 30, 3 } ); |
| |
| Driver noMatcher = tstCreateDriver( notMatchingButLoadedDriverId, 100 ); |
| |
| Device device = tstCreateDevice( new String[]{ "org.apache.felix" } ); |
| |
| final CountDownLatch attachLatch = tstExpectAttach( drivers.get( driverId1 ), device ); |
| |
| final CountDownLatch unloadDriverLatch = new CountDownLatch( 1 ); |
| |
| ServiceReference driver2Ref = m_osgi.getReference( drivers.get( driverId2 ) ); |
| Bundle driver2Bundle = m_osgi.getBundle( driver2Ref ); |
| |
| Answer<Object> answer = new Answer<Object>() { |
| |
| public Object answer(InvocationOnMock invocation) throws Throwable { |
| try { |
| throw new BundleException("test driverBundle uninstall failed"); |
| } |
| finally { |
| unloadDriverLatch.countDown(); |
| } |
| } |
| }; |
| |
| Mockito.doAnswer(answer).when(driver2Bundle).uninstall(); |
| |
| m_manager.locatorAdded( locator ); |
| |
| m_manager.driverAdded( m_osgi.getReference( noMatcher ), noMatcher ); |
| |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !attachLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected an attach" ); |
| } |
| |
| if ( !unloadDriverLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected an unload" ); |
| } |
| |
| |
| //since driver1 is attached, we expect an uninstall() |
| //of all other (dynamically loaded) driver bundles |
| //Driver driver = drivers.get( driverId2 ); |
| //tstVerifyBundleUninstall( driver ); |
| } |
| |
| /** |
| * Two drivers equally match the device. There is a driver selector |
| * that comes to the rescue that selects driver2. |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void EqualMatchWithDriverSelector() throws Exception |
| { |
| |
| final String driverId1 = "org.apache.felix.driver-1.0"; |
| final String driverId2 = "org.apache.felix.driver-1.1"; |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class ); |
| |
| Map<String, Driver> drivers = tstExpectDriverLocatorFor( locator, |
| new String[] { driverId1, driverId2 }, |
| new int[] { 20, 20 } ); |
| |
| Device device = tstCreateDevice( new String[]{ "org.apache.felix" } ); |
| |
| DriverSelector selector = Mockito.mock( DriverSelector.class ); |
| |
| SelectorMatcher matcher = new SelectorMatcher( driverId2 ); |
| |
| Mockito.when( selector.select( |
| Mockito.eq( m_osgi.getReference( device ) ), |
| Mockito.isA(Match[].class) ) ).thenAnswer( matcher ); |
| |
| final CountDownLatch attachLatch = tstExpectAttach( drivers.get( driverId2 ), device ); |
| |
| |
| Utils.inject( m_manager, DriverSelector.class, selector ); |
| |
| m_manager.locatorAdded( locator ); |
| |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !attachLatch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected an attach" ); |
| } |
| |
| |
| //driver2 is attached, so driver1 bundle should uninstall. |
| //Driver driver = drivers.get( driverId1 ); |
| //tstVerifyBundleUninstall( driver ); |
| |
| } |
| |
| |
| //exceptional flow |
| @Test |
| public void DriverLocator_findDriverFails() throws Exception |
| { |
| |
| final CountDownLatch latch = new CountDownLatch( 1 ); |
| |
| Answer<String[]> answer = new Answer<String[]>() |
| { |
| |
| public String[] answer(InvocationOnMock invocation) throws Throwable |
| { |
| latch.countDown(); |
| throw new RuntimeException( "test exception" ); |
| } |
| }; |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class, "locator" ); |
| Mockito.when( locator.findDrivers( Mockito.isA( Dictionary.class ) ) ) |
| .thenAnswer( answer ); |
| |
| Device device = tstCreateDevice( new String[] |
| { "org.apache.felix" } ); |
| |
| final CountDownLatch latch2 = new CountDownLatch( 1 ); |
| |
| Answer<Object> answer2 = new Answer<Object>() |
| { |
| public Object answer(InvocationOnMock invocation) throws Throwable |
| { |
| latch2.countDown(); |
| return null; |
| } |
| }; |
| |
| Mockito.doAnswer(answer2).when(device).noDriverFound(); |
| |
| |
| m_manager.locatorAdded( locator ); |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| if ( !latch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected a call to DriverLocator.findDrivers" ); |
| } |
| |
| if ( !latch2.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected a call to Driver.noDriverFound" ); |
| } |
| |
| } |
| |
| |
| /** |
| * This test verified correct behavior when after a driver |
| * attach led to a referral, this referral leads to an exception. |
| * |
| * |
| * @throws Exception |
| */ |
| @Ignore |
| public void DriverReferral_ReferralFails() throws Exception |
| { |
| |
| final String referredDriver = "org.apache.felix.driver-2.0"; |
| |
| String[] driverIds = new String[] |
| { "org.apache.felix.driver-1.0", "org.apache.felix.driver-1.1" }; |
| |
| int[] driverMatches = new int[]{ 1, Device.MATCH_NONE }; |
| |
| DriverLocator locator = Mockito.mock( DriverLocator.class, "locator for v1.x" ); |
| Map<String, Driver> drivers = tstExpectDriverLocatorFor( locator, driverIds, driverMatches ); |
| |
| |
| DriverLocator locatorv2 = Mockito.mock( DriverLocator.class, "locator for v2.x (fails always)" ); |
| Mockito.when( locatorv2.findDrivers( Mockito.isA( Dictionary.class ) ) ) |
| .thenReturn( null ); |
| |
| Mockito.when( locatorv2.loadDriver( Mockito.startsWith( "org.apache.felix.driver-1" ) ) ) |
| .thenReturn( null ); |
| |
| InputStream referredInputStream = Mockito.mock(InputStream.class); |
| Mockito.when( locatorv2.loadDriver( referredDriver ) ).thenReturn( referredInputStream ); |
| |
| |
| //this is what initial driver referral eventually leads |
| //to: the loading of a driver bundle |
| //we fake it, so that it fails |
| Mockito.when( m_context.installBundle( |
| Mockito.anyString(), |
| Mockito.isA( InputStream.class ) ) ) |
| .thenThrow(new BundleException( "test exception" ) ); |
| |
| Driver matched = drivers.get( "org.apache.felix.driver-1.0" ); |
| |
| final CountDownLatch latch = new CountDownLatch( 1 ); |
| |
| Answer<String> driver10_attach = new Answer<String>() |
| { |
| public String answer(InvocationOnMock invocation) throws Throwable |
| { |
| System.out.println("driver10_attach()"); |
| latch.countDown(); |
| return referredDriver; |
| } |
| }; |
| |
| Device device = tstCreateDevice( new String[]{ "org.apache.felix" } ); |
| |
| |
| Mockito.when( matched.match( m_osgi.getReference( device ) ) ).thenReturn( 10 ); |
| |
| Mockito.when( matched.attach( Mockito.isA( ServiceReference.class ) ) ) |
| .thenAnswer( driver10_attach ); |
| |
| // for ( String driverId : driverIds ) |
| // { |
| // Driver driver = drivers.get( driverId ); |
| // tstExpectBundleUninstall( driver ); |
| // } |
| |
| |
| //the actual test |
| |
| m_manager.locatorAdded( locator ); |
| m_manager.locatorAdded( locatorv2 ); |
| |
| //depman induced callback |
| m_manager.deviceAdded( m_osgi.getReference( device ), device ); |
| |
| |
| if ( !latch.await( 5, TimeUnit.SECONDS ) ) |
| { |
| Assert.fail( "expected an attach to: " + driverIds[0] ); |
| } |
| |
| |
| Mockito.verify(device).noDriverFound(); |
| } |
| |
| /** |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> |
| */ |
| private class MatchAnswer implements Answer<Integer> |
| { |
| |
| private final ServiceReference m_driverRef; |
| |
| public MatchAnswer( ServiceReference driverRef ) |
| { |
| m_driverRef = driverRef; |
| } |
| |
| |
| public Integer answer(InvocationOnMock invocation) throws Throwable |
| { |
| ServiceReference deviceRef = ( ServiceReference ) invocation.getArguments()[0]; |
| String[] categories = String[].class.cast( deviceRef.getProperty( Constants.DEVICE_CATEGORY ) ); |
| String driverId = String.class.cast( m_driverRef.getProperty( Constants.DRIVER_ID ) ); |
| |
| for ( String string : categories ) |
| { |
| if ( driverId.startsWith( string ) ) |
| { |
| Object match = m_driverRef.getProperty( "match" ); |
| return Integer.valueOf( match.toString() ); |
| } |
| } |
| return Device.MATCH_NONE; |
| } |
| |
| } |
| |
| |
| private class SelectorMatcher implements Answer<Integer> |
| { |
| |
| private String m_driverId; |
| |
| |
| public SelectorMatcher( String driverId ) |
| { |
| m_driverId = driverId; |
| } |
| |
| public Integer answer(InvocationOnMock invocation) throws Throwable |
| { |
| int i = 0; |
| Match[] matches = (Match[])invocation.getArguments()[1]; |
| |
| for ( Match match : matches ) |
| { |
| if ( match.getDriver().getProperty( Constants.DRIVER_ID ).equals( m_driverId ) ) |
| { |
| return i; |
| } |
| i++; |
| } |
| return DriverSelector.SELECT_NONE; |
| } |
| |
| |
| } |
| |
| } |
