/*
 * 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;
        }


    }
    
}