Examples of org.apache.felix.scr.Component

org.apache.felix.scr.Component
The Component interface represents a single component managed by the Service Component Runtime. Management agents may access the Component instances through the {@link ScrService}.

    public void test_required_multiple_dynamic_factory() throws InvalidSyntaxException
    {
        final String pid = "test_required_multiple_dynamic_factory";
        final String factoryPid = "factory_" + pid;


        final Component component = findComponentByName( pid );
        TestCase.assertNotNull( component );
        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );


        // async enabling (unsatisfied)
        component.enable();
        delay();
        TestCase.assertEquals( Component.STATE_UNSATISFIED, component.getState() );


        // register service, satisfying
        final SimpleServiceImpl srv1 = SimpleServiceImpl.create( bundleContext, "srv1" );
        delay();
        TestCase.assertEquals( Component.STATE_FACTORY, component.getState() );


        // create a component instance
        final ServiceReference[] refs = bundleContext.getServiceReferences( ComponentFactory.class.getName(), "("
            + ComponentConstants.COMPONENT_FACTORY + "=" + factoryPid + ")" );
        TestCase.assertNotNull( refs );
        TestCase.assertEquals( 1, refs.length );
        final ComponentFactory factory = ( ComponentFactory ) bundleContext.getService( refs[0] );
        TestCase.assertNotNull( factory );


        Hashtable<String, String> props = new Hashtable<String, String>();
        props.put( PROP_NAME_FACTORY, PROP_NAME_FACTORY );
        final ComponentInstance instance = factory.newInstance( props );
        TestCase.assertNotNull( instance );
        TestCase.assertNotNull( instance.getInstance() );
        TestCase.assertEquals( SimpleComponent.INSTANCE, instance.getInstance() );


        // ensure instance is bound
        final SimpleComponent sc = SimpleComponent.INSTANCE;
        TestCase.assertEquals( 1, sc.m_multiRef.size() );
        TestCase.assertTrue( sc.m_multiRef.contains( srv1 ) );


        // ensure factory is not bound
        TestCase.assertNull( component.getReferences()[0].getServiceReferences() );


        // assert two components managed
        final Component[] allFactoryComponents = findComponentsByName( pid );
        TestCase.assertNotNull( allFactoryComponents );
        TestCase.assertEquals( 2, allFactoryComponents.length );
        for ( int i = 0; i < allFactoryComponents.length; i++ )
        {
            final Component c = allFactoryComponents[i];
            if ( c.getId() == component.getId() )
            {
                TestCase.assertEquals( Component.STATE_FACTORY, c.getState() );
            }
            else if ( c.getId() == SimpleComponent.INSTANCE.m_id )
            {
                TestCase.assertEquals( Component.STATE_ACTIVE, c.getState() );
            }
            else
            {
                TestCase.fail( "Unexpected Component " + c );
            }
        }


        // register second service
        final SimpleServiceImpl srv11 = SimpleServiceImpl.create( bundleContext, "srv11" );
        delay();


        // ensure instance is bound
        TestCase.assertEquals( 2, sc.m_multiRef.size() );
        TestCase.assertTrue( sc.m_multiRef.contains( srv1 ) );
        TestCase.assertTrue( sc.m_multiRef.contains( srv11 ) );


        // ensure factory is not bound
        TestCase.assertNull( component.getReferences()[0].getServiceReferences() );


        // drop second service and ensure unbound (and active)
        srv11.drop();
        delay();
        TestCase.assertNotNull( instance.getInstance() );
        TestCase.assertEquals( SimpleComponent.INSTANCE, instance.getInstance() );
        TestCase.assertEquals( 1, sc.m_multiRef.size() );
        TestCase.assertTrue( sc.m_multiRef.contains( srv1 ) );
        TestCase.assertNull( component.getReferences()[0].getServiceReferences() );




        // remove the service, expect factory to deactivate and instance to dispose
        srv1.drop();
        delay();


        TestCase.assertEquals( Component.STATE_UNSATISFIED, component.getState() );
        TestCase.assertNull( instance.getInstance() );


        // assert component factory only managed
        final Component[] allFactoryComponents2 = findComponentsByName( pid );
        TestCase.assertNotNull( allFactoryComponents2 );
        TestCase.assertEquals( 1, allFactoryComponents2.length );
        for ( int i = 0; i < allFactoryComponents2.length; i++ )
        {
            final Component c = allFactoryComponents2[i];
            if ( c.getId() == component.getId() )
            {
                TestCase.assertEquals( Component.STATE_UNSATISFIED, c.getState() );
            }
            else
            {
                TestCase.fail( "Unexpected Component " + c );
            }
        }


        // registeranother service, factory must come back, instance not
        final SimpleServiceImpl srv2 = SimpleServiceImpl.create( bundleContext, "srv2" );
        delay();


        TestCase.assertEquals( Component.STATE_FACTORY, component.getState() );
        TestCase.assertNull( instance.getInstance() );


        // assert component factory only managed
        final Component[] allFactoryComponents3 = findComponentsByName( pid );
        TestCase.assertNotNull( allFactoryComponents3 );
        TestCase.assertEquals( 1, allFactoryComponents3.length );
        for ( int i = 0; i < allFactoryComponents3.length; i++ )
        {
            final Component c = allFactoryComponents3[i];
            if ( c.getId() == component.getId() )
            {
                TestCase.assertEquals( Component.STATE_FACTORY, c.getState() );
            }
            else
            {
                TestCase.fail( "Unexpected Component " + c );
            }

View Full Code Here




    @Test
    public void test_optional_single_static()
    {
        final Component component = findComponentByName( "test_optional_single_static" );
        TestCase.assertNotNull( component );
        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );


        final SimpleServiceImpl srv1 = SimpleServiceImpl.create( bundleContext, "srv1" );


        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp10 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp10 );
        TestCase.assertEquals( srv1, comp10.m_singleRef );
        TestCase.assertTrue( comp10.m_multiRef.isEmpty() );


        srv1.drop();
        delay(); // async reactivate


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp11 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp10, comp11 );
        TestCase.assertNull( comp11.m_singleRef );
        TestCase.assertTrue( comp11.m_multiRef.isEmpty() );


        final SimpleServiceImpl srv2 = SimpleServiceImpl.create( bundleContext, "srv2" );
        delay(); // async binding


        // greedy static reference rebinds
        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp12 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp10, comp12 );
        TestCase.assertNotSame( comp11, comp12 );
        TestCase.assertEquals( srv2, comp12.m_singleRef );
        TestCase.assertTrue( comp12.m_multiRef.isEmpty() );


        component.disable();
        delay(); // async disabling


        final SimpleServiceImpl srv3 = SimpleServiceImpl.create( bundleContext, "srv3" );


        // enable component with two services available, expect srv2 bind
        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp20 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp20 );
        TestCase.assertNotSame( comp10, comp20 );
        TestCase.assertEquals( srv2, comp20.m_singleRef );
        TestCase.assertTrue( comp20.m_multiRef.isEmpty() );


        // drop srv2, expect rebind to srv3 (synchronously)
        srv2.drop();
        delay(); // async reactivate


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp21 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp20, comp21 );
        TestCase.assertEquals( srv3, comp21.m_singleRef );
        TestCase.assertTrue( comp21.m_multiRef.isEmpty() );


        // create srv4 of lower rank, expect no rebind
        final SimpleServiceImpl srv4 = SimpleServiceImpl.create( bundleContext, "srv4", -1 );
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp22 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp20, comp22 );
        TestCase.assertSame( comp21, comp22 );
        TestCase.assertEquals( srv3, comp22.m_singleRef );
        TestCase.assertTrue( comp22.m_multiRef.isEmpty() );


        // drop srv4 again, expect no rebind
        srv4.drop();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp23 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp20, comp23 );
        TestCase.assertSame( comp21, comp23 );
        TestCase.assertSame( comp22, comp23 );
        TestCase.assertEquals( srv3, comp23.m_singleRef );
        TestCase.assertTrue( comp23.m_multiRef.isEmpty() );


        // "reset"
        component.disable();
        srv3.drop();
        delay();


        // two services with service ranking (srv6 > srv5)
        final SimpleServiceImpl srv5 = SimpleServiceImpl.create( bundleContext, "srv5", 10 );
        final SimpleServiceImpl srv6 = SimpleServiceImpl.create( bundleContext, "srv6", 20 );


        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp30 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp23, comp30 );
        TestCase.assertEquals( srv6, comp30.m_singleRef );
        TestCase.assertTrue( comp30.m_multiRef.isEmpty() );


        // another service with higher ranking rebind !
        final SimpleServiceImpl srv7 = SimpleServiceImpl.create( bundleContext, "srv7", 30 );
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp31 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp30, comp31 );
        TestCase.assertEquals( srv7, comp31.m_singleRef );
        TestCase.assertTrue( comp31.m_multiRef.isEmpty() );


        // srv6 goes, rebind to srv7
        srv6.drop();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp32 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp30, comp32 );
        TestCase.assertSame( comp31, comp32 );
        TestCase.assertEquals( srv7, comp32.m_singleRef );
        TestCase.assertTrue( comp32.m_multiRef.isEmpty() );

View Full Code Here




    @Test
    public void test_required_single_static()
    {
        final Component component = findComponentByName( "test_required_single_static" );
        TestCase.assertNotNull( component );
        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );


        final SimpleServiceImpl srv1 = SimpleServiceImpl.create( bundleContext, "srv1" );


        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp10 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp10 );
        TestCase.assertEquals( srv1, comp10.m_singleRef );
        TestCase.assertTrue( comp10.m_multiRef.isEmpty() );


        srv1.drop();
        delay(); // async reactivate


        TestCase.assertEquals( Component.STATE_UNSATISFIED, component.getState() );
        final SimpleComponent comp11 = SimpleComponent.INSTANCE;
        TestCase.assertNull( comp11 );


        final SimpleServiceImpl srv2 = SimpleServiceImpl.create( bundleContext, "srv2" );
        delay(); // async binding


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp12 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp10, comp12 );
        TestCase.assertEquals( srv2, comp12.m_singleRef );
        TestCase.assertTrue( comp12.m_multiRef.isEmpty() );


        component.disable();
        delay(); // async disabling


        final SimpleServiceImpl srv3 = SimpleServiceImpl.create( bundleContext, "srv3" );


        // enable component with two services available, expect srv2 bind
        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp20 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp20 );
        TestCase.assertNotSame( comp10, comp20 );
        TestCase.assertEquals( srv2, comp20.m_singleRef );
        TestCase.assertTrue( comp20.m_multiRef.isEmpty() );


        // drop srv2, expect rebind to srv3
        srv2.drop();
        delay(); // async reactivate


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp21 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp20, comp21 );
        TestCase.assertEquals( srv3, comp21.m_singleRef );
        TestCase.assertTrue( comp21.m_multiRef.isEmpty() );


        // create srv4, expect no rebind
        final SimpleServiceImpl srv4 = SimpleServiceImpl.create( bundleContext, "srv4" );
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp22 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp20, comp22 );
        TestCase.assertSame( comp21, comp22 );
        TestCase.assertEquals( srv3, comp22.m_singleRef );
        TestCase.assertTrue( comp22.m_multiRef.isEmpty() );


        // drop srv4 again, expect no rebind
        srv4.drop();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp23 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp20, comp23 );
        TestCase.assertSame( comp21, comp23 );
        TestCase.assertSame( comp22, comp23 );
        TestCase.assertEquals( srv3, comp23.m_singleRef );
        TestCase.assertTrue( comp23.m_multiRef.isEmpty() );


        // "reset"
        component.disable();
        srv3.drop();
        delay();


        // two services with service ranking (srv6 > srv5)
        final SimpleServiceImpl srv5 = SimpleServiceImpl.create( bundleContext, "srv5", 10 );
        final SimpleServiceImpl srv6 = SimpleServiceImpl.create( bundleContext, "srv6", 20 );


        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp30 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp23, comp30 );
        TestCase.assertEquals( srv6, comp30.m_singleRef );
        TestCase.assertTrue( comp30.m_multiRef.isEmpty() );


        // another service with higher ranking -- rebind !
        final SimpleServiceImpl srv7 = SimpleServiceImpl.create( bundleContext, "srv7", 30 );
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp31 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp30, comp31 );
        TestCase.assertEquals( srv7, comp31.m_singleRef );
        TestCase.assertTrue( comp31.m_multiRef.isEmpty() );


        // srv6 goes, no rebind to srv7
        srv6.drop();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp32 = SimpleComponent.INSTANCE;
        TestCase.assertNotSame( comp30, comp32 );
        TestCase.assertSame( comp31, comp32 );
        TestCase.assertEquals( srv7, comp32.m_singleRef );
        TestCase.assertTrue( comp32.m_multiRef.isEmpty() );

View Full Code Here

        singleTest( pid, false );
    }


    private void singleTest(String pid, boolean dynamic)
    {
        final Component component = findComponentByName( pid );
        TestCase.assertNotNull( component );
        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );


        final SimpleServiceImpl srv1 = SimpleServiceImpl.create( bundleContext, "srv1" );
        final SimpleServiceImpl srv2 = SimpleServiceImpl.create( bundleContext, "srv2" );


        theConfig.put("ref.target", "(value=srv1)");
        configure( pid );
        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp10 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp10 );
        TestCase.assertEquals( srv1, comp10.m_singleRef );
        TestCase.assertTrue( comp10.m_multiRef.isEmpty() );
        TestCase.assertEquals( 1, comp10.m_singleRefBind );
        TestCase.assertEquals( 0, comp10.m_singleRefUnbind);


        // update configuration to target srv2
        theConfig.put("ref.target", "(value=srv2)");
        configure( pid );


        delay();
        // should bind to srv2
        SimpleComponent comp20;
        if ( dynamic )
        {
            TestCase.assertEquals( 1, comp10.m_modified );
            comp20 = comp10;
            TestCase.assertEquals( 2, comp20.m_singleRefBind );
            TestCase.assertEquals( 1, comp20.m_singleRefUnbind);
        } 
        else
        {
            TestCase.assertEquals( 0, comp10.m_modified );
            comp20 = SimpleComponent.INSTANCE;
            TestCase.assertNotSame( comp10, comp20 );
            TestCase.assertEquals( 0, comp20.m_modified );
            TestCase.assertEquals( 1, comp20.m_singleRefBind );
            TestCase.assertEquals( 0, comp20.m_singleRefUnbind);
            TestCase.assertEquals( 1, comp10.m_singleRefUnbind);
        }
        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        TestCase.assertEquals( srv2, comp20.m_singleRef );
        TestCase.assertTrue( comp20.m_multiRef.isEmpty() );
    }

View Full Code Here

        multipleTest( pid, false );
    }


    private void multipleTest(String pid, boolean dynamic)
    {
        final Component component = findComponentByName( pid );
        TestCase.assertNotNull( component );
        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );


        final SimpleServiceImpl srv1 = SimpleServiceImpl.create( bundleContext, "srv1" );
        final SimpleServiceImpl srv2 = SimpleServiceImpl.create( bundleContext, "srv2" );


        theConfig.put("ref.target", "(value=srv1)");
        configure( pid );
        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        final SimpleComponent comp10 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp10 );
        TestCase.assertEquals( 1, comp10.m_multiRef.size() );
        TestCase.assertEquals( srv1, comp10.m_multiRef.iterator().next() );
        TestCase.assertEquals( 1, comp10.m_multiRefBind );
        TestCase.assertEquals( 0, comp10.m_multiRefUnbind);


        // update configuration to target srv2
        theConfig.put("ref.target", "(value=srv2)");
        configure( pid );


        delay();
        // should bind to srv2
        SimpleComponent comp20;
        if ( dynamic )
        {
            TestCase.assertEquals( 1, comp10.m_modified );
            comp20 = comp10;
            TestCase.assertEquals( 2, comp20.m_multiRefBind );
            TestCase.assertEquals( 1, comp20.m_multiRefUnbind);
        } 
        else
        {
            TestCase.assertEquals( 0, comp10.m_modified );
            comp20 = SimpleComponent.INSTANCE;
            TestCase.assertNotSame( comp10, comp20 );
            TestCase.assertEquals( 0, comp20.m_modified );
            TestCase.assertEquals( 1, comp20.m_multiRefBind );
            TestCase.assertEquals( 0, comp20.m_multiRefUnbind);
            TestCase.assertEquals( 1, comp10.m_multiRefUnbind);
        }
        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        TestCase.assertEquals( 1, comp20.m_multiRef.size() );
        TestCase.assertEquals( srv2, comp20.m_multiRef.iterator().next() );
    }

View Full Code Here

    public void testSingleDynamicRequiredFactory() throws InvalidSyntaxException
    {
        String pid = "test_required_single_dynamic_factory";
        final String factoryPid = "factory_" + pid;
        boolean dynamic = true;
        final Component component = findComponentByName( pid );
        TestCase.assertNotNull( component );
        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );


        final SimpleServiceImpl srv1 = SimpleServiceImpl.create( bundleContext, "srv1" );
        final SimpleServiceImpl srv2 = SimpleServiceImpl.create( bundleContext, "srv2" );


        theConfig.put("ref.target", "(value=srv1)");
        configure( pid );
        // async enabling
        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_FACTORY, component.getState() );
        
        // create a component instance
        final ServiceReference[] refs = bundleContext.getServiceReferences( ComponentFactory.class.getName(), "("
            + ComponentConstants.COMPONENT_FACTORY + "=" + factoryPid + ")" );
        TestCase.assertNotNull( refs );
        TestCase.assertEquals( 1, refs.length );
        final ComponentFactory factory = ( ComponentFactory ) bundleContext.getService( refs[0] );
        TestCase.assertNotNull( factory );


        Hashtable<String, String> props = new Hashtable<String, String>();
        props.put( PROP_NAME_FACTORY, PROP_NAME_FACTORY );
        final ComponentInstance instance = factory.newInstance( props );
        TestCase.assertNotNull( instance );
        TestCase.assertNotNull( instance.getInstance() );
        TestCase.assertEquals( SimpleComponent.INSTANCE, instance.getInstance() );


        final SimpleComponent comp10 = SimpleComponent.INSTANCE;
        TestCase.assertNotNull( comp10 );
        TestCase.assertEquals( srv1, comp10.m_singleRef );
        TestCase.assertTrue( comp10.m_multiRef.isEmpty() );
        TestCase.assertEquals( 1, comp10.m_singleRefBind );
        TestCase.assertEquals( 0, comp10.m_singleRefUnbind);


        // update configuration to target srv2
        theConfig.put("ref.target", "(value=srv2)");
        configure( pid );


        delay();
        // should bind to srv2
        SimpleComponent comp20;
        if ( dynamic )
        {
            //fails here, config modifications are not propagated to instances from factory.
            TestCase.assertEquals( 1, comp10.m_modified );
            comp20 = comp10;
            TestCase.assertEquals( 2, comp20.m_singleRefBind );
            TestCase.assertEquals( 1, comp20.m_singleRefUnbind);
        } 
        else
        {
            TestCase.assertEquals( 0, comp10.m_modified );
            comp20 = SimpleComponent.INSTANCE;
            TestCase.assertNotSame( comp10, comp20 );
            TestCase.assertEquals( 0, comp20.m_modified );
            TestCase.assertEquals( 1, comp20.m_singleRefBind );
            TestCase.assertEquals( 0, comp20.m_singleRefUnbind);
            TestCase.assertEquals( 1, comp10.m_singleRefUnbind);
        }
        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        TestCase.assertEquals( srv2, comp20.m_singleRef );
        TestCase.assertTrue( comp20.m_multiRef.isEmpty() );
    }

View Full Code Here

        doTest("MultipleStaticReluctant");
    }


    protected void doTest(String componentName)
    {
        final Component main = findComponentByName(componentName);
        TestCase.assertNotNull(main);


        ServiceRegistration dep1Reg = register(new SimpleComponent(), 0);
        ServiceRegistration dep2Reg = register(new SimpleComponent2(), 1000);
        main.enable();
        delay(300);
        dep1Reg.unregister();
        delay(2000);


        ComponentInstance mainCompInst = main.getComponentInstance();
        TestCase.assertNull(mainCompInst);


        dep1Reg = register(new SimpleComponent(), 0);
        delay(300);


        mainCompInst = main.getComponentInstance();
        TestCase.assertNotNull(mainCompInst);


        main.disable();
        dep1Reg.unregister();
        dep2Reg.unregister();


        dep1Reg = register(new SimpleComponent(), 0);
        dep2Reg = register(new SimpleComponent2(), 1000);
        main.enable();
        delay(300);
        dep1Reg.unregister();
        delay(100);
        dep1Reg = register(new SimpleComponent(), 0);
        delay(2000);


        mainCompInst = main.getComponentInstance();
        TestCase.assertNotNull(mainCompInst);
    }

View Full Code Here

    @Test
    public void testAsyncLocate() throws Exception
    {
        bundleContext.registerService( Object.class, new Object(), null );
        
        final Component consumerComponent = findComponentByName( "AsyncLocate" );
        TestCase.assertNotNull( consumerComponent );
        TestCase.assertEquals( Component.STATE_ACTIVE, consumerComponent.getState() );
        
        final String pid = "SimpleComponent";
        Configuration config = getConfigurationAdmin().getConfiguration( pid, null );
        final Hashtable props = new Hashtable();
        props.put( "target", "bar" );
        config.update(props);
        delay();
        
        final Component component = findComponentByName( pid );
        TestCase.assertNotNull( component );
        //when deadlock is present the state is actually unsatisfied.
        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        delay();
        props.put( "target", "foo" );
        config.update(props);
        delay();
       
        TestComponent tc = (TestComponent) component.getComponentInstance().getInstance();
        assertTrue(tc.isSuccess1());
        assertTrue(tc.isSuccess2());
    }

View Full Code Here

    }


    @Test
    public void test_concurrent_reference_bindings()
    {
        final Component main =
                findComponentByName("org.apache.felix.scr.integration.components.felix3680.Main");
        TestCase.assertNotNull(main);
        main.enable();


        delay(30);
        main.disable();
        delay( ); //async deactivate
        for (Iterator it = log.foundWarnings().iterator(); it.hasNext();)
        {
            String message = (String) it.next();
            if (message.startsWith("Performed ") && message.endsWith(" tests."))

View Full Code Here


    @Test
    public void testLocationBinding() throws Exception
    {
        final String pid = COMPONENT_NAME;
        final Component component = findComponentByName( pid );


        deleteConfig( pid );
        delay();


        TestCase.assertNotNull( component );
        TestCase.assertFalse( component.isDefaultEnabled() );


        TestCase.assertEquals( Component.STATE_DISABLED, component.getState() );
        TestCase.assertNull( SimpleComponent.INSTANCE );


        component.enable();
        delay();


        TestCase.assertEquals( Component.STATE_UNSATISFIED, component.getState() );
        TestCase.assertNull( SimpleComponent.INSTANCE );


        Configuration config = configure( pid );
        delay();


        TestCase.assertEquals( Component.STATE_ACTIVE, component.getState() );
        TestCase.assertNotNull( SimpleComponent.INSTANCE );
        TestCase.assertEquals( PROP_NAME, SimpleComponent.INSTANCE.getProperty( PROP_NAME ) );
        
        
        Bundle b2 = installBundle( descriptorFile, COMPONENT_PACKAGE, "simplecomponent2", "0.0.11", null );
        b2.start();
        Component[] components = findComponentsByName( pid );
        TestCase.assertEquals( 2, components.length );
        Component c2 = components[0] == component? components[1]: components[0];
        
        c2.enable();
        delay();
        TestCase.assertEquals( Component.STATE_UNSATISFIED, c2.getState() );
        
        bundle.stop();
        delay();
        
        TestCase.assertEquals( Component.STATE_UNSATISFIED, c2.getState() );


        ConfigurationListener listener = new ConfigurationListener() {


            public void configurationEvent(ConfigurationEvent event)
            {
                if (event.getType() == ConfigurationEvent.CM_LOCATION_CHANGED)
                {
                    eventReceived = true;
                }
            }
            
        };
        ServiceRegistration<ConfigurationListener> sr = bundleContext.registerService( ConfigurationListener.class, listener, null );
        config.setBundleLocation( null );
        delay();
        
        if ( eventReceived )
        {
            TestCase.assertEquals( Component.STATE_ACTIVE, c2.getState() );
        }
        
        sr.unregister();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.felix.scr.Component

com.adobe.acs.commons.util.impl.ComponentDisablerTest

org.apache.felix.scr.impl.ScrCommand

org.apache.felix.scr.integration.CircularReferenceTest

org.apache.felix.scr.integration.ComponentActivationTest

org.apache.felix.scr.integration.ComponentConcurrencyTest

org.apache.felix.scr.integration.ComponentConfigurationPidTest

org.apache.felix.scr.integration.ComponentConfigurationTest

org.apache.felix.scr.integration.ComponentFactoryTest

org.apache.felix.scr.integration.ComponentTestBase

org.apache.felix.scr.integration.ConfigurationChangeTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.