svn commit: r615675 [2/21] - in /felix/sandbox/clement/ipojo: ./ annotations/ ant/ arch/ core/ core/src/main/java/org/apache/felix/ipojo/handlers/configuration/ core/src/main/java/org/apache/felix/ipojo/handlers/dependency/ core/src/main/java/org/apach...

[cl...@apache.org]

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TataProvider.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TataProvider.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TataProvider.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TataProvider.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,204 @@
+package org.apache.felix.ipojo.test.composite.component;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.composite.service.Tata;
+
+
+public class TataProvider implements Tata {
+    
+    int tata = 0;
+    int tataStr = 0;
+    int tataStrs = 0;
+    int tata_2 = 0;
+    int tata_3 = 0;
+    int tata1 = 0;
+    int tata1_1 = 0;
+    int tata5 = 0;
+    int tata5_1 = 0;
+    int tata5_2 = 0;
+    int tataBoolean = 0;
+    int tataBooleans = 0;
+    int tataByte = 0;
+    int tataBytes = 0;
+    private int add;
+    private int tataShorts;
+    private int tataShort;
+    private int tataLongs;
+    private int tataLong;
+    private int tataInts;
+    private int tataInt;
+    private int tataFloat;
+    private int tataFloats;
+    private int tataDoubles;
+    private int tataDouble;
+    private int tataChars;
+    private int tataChar;
+    
+    public Properties getPropsTata() {
+        Properties props = new Properties();
+        props.put("tata", new Integer(tata));
+        props.put("tataStr", new Integer(tataStr));
+        props.put("tataStrs", new Integer(tataStrs));
+        props.put("tata_2", new Integer(tata_2));
+        props.put("tata_3", new Integer(tata_3));
+        props.put("tata1", new Integer(tata1));
+        props.put("tata1_1", new Integer(tata1_1));
+        props.put("tata5", new Integer(tata5));
+        props.put("tata5_1", new Integer(tata5_1));
+        props.put("tata5_2", new Integer(tata5_2));
+        props.put("add", new Integer(add));
+        props.put("tataBoolean", new Integer(tataBoolean));
+        props.put("tataBoolean", new Integer(tataBoolean));
+        props.put("tataByte", new Integer(tataByte));
+        props.put("tataBytes", new Integer(tataBytes));
+        props.put("tataShort", new Integer(tataShort));
+        props.put("tataShorts", new Integer(tataShorts));
+        props.put("tataLongs", new Integer(tataLongs));
+        props.put("tataLong", new Integer(tataLong));
+        props.put("tataInt", new Integer(tataInt));
+        props.put("tataInts", new Integer(tataInts));
+        props.put("tataFloat", new Integer(tataFloat));
+        props.put("tataFloats", new Integer(tataFloats));
+        props.put("tataDouble", new Integer(tataDouble));
+        props.put("tataDoubles", new Integer(tataDoubles));
+        props.put("tataChar", new Integer(tataChar));
+        props.put("tataChars", new Integer(tataChars));
+        return props;
+    }
+
+    public void tata() {
+        tata++;
+    }
+
+    public String tataStr() {
+        tataStr++;
+        return "Tata";
+    }
+
+    public String[] tataStrs() {
+        tataStrs++;
+        return new String[] {"T", "A", "T", "A"};
+    }
+
+    public void tata(int i, int j) {
+        tata_2++;        
+    }
+
+    public void tata(String s) {
+        tata_3++;
+    }
+
+    public String tata1(String a) {
+        tata1++;
+       return a;
+    }
+
+    public String tata1(char[] a) {
+        tata1_1++;
+        String s = new String(a);
+        return s;
+    }
+
+    public String tata5(String a, int i) {
+       tata5++;
+       return a+i;
+    }
+
+    public String tata5(String[] a, int i) {
+       tata5_1++;
+       return ""+a.length + i;
+    }
+
+    public String tata5(String a, int[] i) {
+        tata5_2++;
+        return a + i.length;
+    }
+
+    public boolean tataBoolean(boolean b) {
+        tataBoolean++;
+        return b;
+    }
+
+    public boolean[] tataBooleans(boolean[] b) {
+        tataBooleans++;
+       return b;
+    }
+
+    public byte tataByte(byte b) {
+        tataByte++;
+        return b;
+    }
+
+    public byte[] tataBytes(byte[] b) {
+        tataBytes++;
+        return b;
+    }
+
+    public char tataChar(char c) {
+       tataChar++;
+       return c;
+    }
+
+    public char[] tataChars(char[] c) {
+        tataChars++;
+        return c;
+    }
+
+    public double tataDouble(double d) {
+        tataDouble++;
+        return d;
+    }
+
+    public double[] tataDoubles(double[] d) {
+        tataDoubles++;
+        return d;
+    }
+
+    public float tataFloat(float f) {
+        tataFloat++;
+        return f;
+    }
+
+    public float[] tataFloats(float[] f) {
+        tataFloats++;
+        return f;
+    }
+
+    public int tataInt(int i) {
+        tataInt++;
+        return i;
+    }
+
+    public int[] tataInts(int[] its) {
+        tataInts++;
+        return its;
+    }
+
+    public long tataLong(long l) {
+        tataLong++;
+        return l;
+    }
+
+    public long[] tataLongs(long[] l) {
+        tataLongs++;
+        return l;
+    }
+
+    public short tataShort(short s) {
+        tataShort++;
+        return s;
+    }
+
+    public short[] tataShorts(short[] s) {
+        tataShorts++;
+        return s;
+    }
+
+    public long add(int i, int j, int k) {
+        add++;
+        return i + j + k;
+    }
+
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProvider.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProvider.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProvider.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProvider.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,55 @@
+package org.apache.felix.ipojo.test.composite.component;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.composite.service.Toto;
+
+
+public class TotoProvider implements Toto {
+    
+    private int i = 0;
+    public static int toto = 0;
+    public static int toto_2 = 0;
+    public static int toto_3 = 0;
+    public static int toto_4 = 0;
+    public static int toto1 = 0;
+    
+    public int count() {
+        return i;
+    }
+    
+    public void toto() {
+        toto++;        
+    }
+
+    public void toto(int i, int j) {
+        toto_2++;
+    }
+
+    public String toto(String a) {
+        toto_3++;
+        return a;
+    }
+
+    public String toto(String[] a) {
+        toto_4++;
+        return "toto";
+    }
+
+    public void toto1(String j) {
+        i++;
+        toto1++;        
+    }
+
+    public Properties getProps() {
+        Properties props = new Properties();
+        props.put("i", new Integer(i));
+        props.put("toto", new Integer(toto));
+        props.put("toto_2", new Integer(toto_2));
+        props.put("toto_3", new Integer(toto_3));
+        props.put("toto_4", new Integer(toto_4));
+        props.put("toto1", new Integer(toto1));
+        return props;
+    }
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProviderGlue.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProviderGlue.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProviderGlue.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/component/TotoProviderGlue.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,63 @@
+package org.apache.felix.ipojo.test.composite.component;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.composite.service.Toto;
+
+
+public class TotoProviderGlue implements Toto {
+    
+    Toto m_toto;
+    
+    private int i = 0;
+    public static int toto = 0;
+    public static int toto_2 = 0;
+    public static int toto_3 = 0;
+    public static int toto_4 = 0;
+    public static int toto1 = 0;
+    
+    public int count() {
+        return i;
+    }
+    
+    public void toto() {
+        toto++;
+        m_toto.toto();
+    }
+
+    public void toto(int i, int j) {
+        toto_2++;
+        m_toto.toto(i, j);
+    }
+
+    public String toto(String a) {
+        toto_3++;
+        return a;
+    }
+
+    public String toto(String[] a) {
+        toto_4++;
+        return "toto";
+    }
+
+    public void toto1(String j) {
+        i++;
+        toto1++;
+        m_toto.toto1(j);
+    }
+
+    public Properties getProps() {
+        Properties props = new Properties();
+        props.put("i", new Integer(i));
+        props.put("gtoto", new Integer(toto));
+        props.put("gtoto_2", new Integer(toto_2));
+        props.put("gtoto_3", new Integer(toto_3));
+        props.put("gtoto_4", new Integer(toto_4));
+        props.put("gtoto1", new Integer(toto1));
+        props.put("glue", "glue");
+        Properties p2 = m_toto.getProps();
+        props.putAll(p2);
+        return props;
+    }
+
+}

Propchange: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Sun Jan 27 15:21:24 2008
@@ -0,0 +1,6 @@
+target*
+bin*
+.settings*
+.classpath
+.project
+.checkstyle

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/ExportTestSuite.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/ExportTestSuite.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/ExportTestSuite.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/ExportTestSuite.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,22 @@
+package org.apache.felix.ipojo.test.composite.exporter;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import org.apache.felix.ipojo.junit4osgi.OSGiTestSuite;
+import org.osgi.framework.BundleContext;
+
+public class ExportTestSuite extends TestSuite {
+
+	public static Test suite(BundleContext bc) {
+		OSGiTestSuite ots = new OSGiTestSuite("Composite Service Exporters Test Suite", bc);
+		ots.addTestSuite(SimpleExport.class);
+		ots.addTestSuite(OptionalExport.class);
+		ots.addTestSuite(MultipleExport.class);
+		ots.addTestSuite(OptionalMultipleExport.class);
+		ots.addTestSuite(FilteredExport.class);
+		ots.setBundleContext(bc);
+		return ots;
+	}
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/FilteredExport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/FilteredExport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/FilteredExport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/FilteredExport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,212 @@
+package org.apache.felix.ipojo.test.composite.exporter;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.BazService;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class FilteredExport extends OSGiTestCase {
+	
+	ComponentInstance export1;
+	Factory fooProvider;
+	ComponentInstance foo1 = null, foo2 = null;
+	
+	public void setUp() {
+		fooProvider = Utils.getFactoryByName(context, "BazProviderType");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Fail to create foos : " + e.getMessage());
+		}
+		
+		foo1.stop();
+		foo2.stop();
+		
+		Factory factory = Utils.getFactoryByName(context, "composite.export.5");
+		Properties props = new Properties();
+		props.put("name", "export");
+		try {
+			export1 = factory.createComponentInstance(props);
+		} catch(Exception e) {
+			fail("Fail to instantiate exporter " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		export1.dispose();
+		foo1 = null;
+		foo2 = null;
+		export1 = null;
+	}
+	
+	public void test1() {
+		export1.start();
+		
+		// Check that no foo service are available
+		assertEquals("Check no foo service", Utils.getServiceReferences(context, FooService.class.getName(), null).length, 0);
+		
+		// Test invalidity
+		assertTrue("Check invalidity - 0", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 3", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo2.stop();
+		assertTrue("Check invalidity - 4", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check invalidity - 5", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 0);
+	}
+	
+	public void test2() {
+		export1.start();
+		
+		// Test invalidity
+		assertTrue("Check invalidity - 0", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke());
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 4", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 5", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke());
+	}
+	
+	public void test3() {
+		foo1.start();
+		foo2.start();
+		
+		export1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 2", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 0);
+		
+		foo2.stop();
+		assertTrue("Check invalidity - 3", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 4", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke());
+	}
+	
+	public void test4() {
+		foo1.start();
+		foo2.start();
+		
+		export1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 3", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check invalidity - 4", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+	}
+	
+	
+	
+	private boolean isFooServiceProvided() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export1.getInstanceName());
+		return ref != null;
+	}
+	
+	private int countFooServiceProvided() {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export1.getInstanceName()+")");
+		return refs.length;
+	}
+	
+	private boolean invoke() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export1.getInstanceName());
+		if(ref == null) { return false; }
+		BazService fs = (BazService) context.getService(ref);
+		return fs.foo();
+	}
+	
+	
+	
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/MultipleExport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/MultipleExport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/MultipleExport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/MultipleExport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,229 @@
+package org.apache.felix.ipojo.test.composite.exporter;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.BazService;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class MultipleExport extends OSGiTestCase {
+	
+	ComponentInstance export3;
+	Factory fooProvider;
+	ComponentInstance foo1 = null, foo2 = null;
+
+	public void setUp() {
+		fooProvider = Utils.getFactoryByName(context, "BazProviderType");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Fail to create foos : " + e.getMessage());
+		}
+		
+		foo1.stop();
+		foo2.stop();
+		
+		Factory factory = Utils.getFactoryByName(context, "composite.export.3");
+		Properties props = new Properties();
+		props.put("name", "export");
+		try {
+			export3 = factory.createComponentInstance(props);
+		} catch(Exception e) {
+			fail("Fail to instantiate exporter " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		export3.dispose();
+		foo1 = null;
+		foo2 = null;
+		export3 = null;
+	}
+	
+	public void test1() {
+		export3.start();
+		
+		// Check that no foo service are available
+		assertEquals("Check no foo service", Utils.getServiceReferences(context, FooService.class.getName(), null).length, 0);
+		
+		// Test invalidity
+		assertTrue("Check invalidity - 0", export3.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke(1));
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 2", invoke(2));
+		
+		foo1.stop();
+		assertTrue("Check validity - 3", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3 ("+countFooServiceProvided()+")", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke(1));
+		
+		foo2.stop();
+		assertTrue("Check invalidity - 4", export3.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 5", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke(1));
+	}
+	
+	public void test2() {
+		export3.start();
+		
+		// Test invalidity
+		assertTrue("Check invalidity - 0", export3.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 2", invoke(2));
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke(1));
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 4", export3.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 5", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke(1));
+	}
+	
+	public void test3() {
+		foo1.start();
+		foo2.start();
+		
+		export3.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 1", invoke(2));
+		
+		foo1.stop();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke(1));
+		
+		foo2.stop();
+		assertTrue("Check invalidity - 3", export3.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 4", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke(1));
+	}
+	
+	public void test4() {
+		foo1.start();
+		foo2.start();
+		
+		export3.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 1", invoke(2));
+		
+		foo2.stop();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke(1));
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 3", export3.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 4", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke(1));
+	}
+	
+	
+	
+	private boolean isFooServiceProvided() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export3.getInstanceName());
+		return ref != null;
+	}
+	
+	private int countFooServiceProvided() {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export3.getInstanceName()+")");
+		return refs.length;
+	}
+	
+	private boolean invoke() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export3.getInstanceName());
+		if(ref == null) { return false; }
+		BazService fs = (BazService) context.getService(ref);
+		context.ungetService(ref);
+		return fs.foo();
+	}
+	
+	private boolean invoke(int nb) {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export3.getInstanceName()+")");
+		if(refs == null) { return false; }
+		if (nb > refs.length) { return false; }
+		for(int i = 0; i < nb; i++) {
+			BazService fs = (BazService) context.getService(refs[i]);
+			context.ungetService(refs[i]);
+			if(!fs.foo()) { return false; }
+		}
+		return true;
+	}
+	
+	
+	
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalExport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalExport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalExport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalExport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,216 @@
+package org.apache.felix.ipojo.test.composite.exporter;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.BazService;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class OptionalExport extends OSGiTestCase {
+	
+	ComponentInstance export2;
+	Factory fooProvider;
+	ComponentInstance foo1 = null, foo2 = null;
+
+	public void setUp() {
+		fooProvider = Utils.getFactoryByName(context, "BazProviderType");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Fail to create foos : " + e.getMessage());
+		}
+		
+		foo1.stop();
+		foo2.stop();
+		
+		Factory factory = Utils.getFactoryByName(context, "composite.export.2");
+		Properties props = new Properties();
+		props.put("name", "export");
+		try {
+			export2 = factory.createComponentInstance(props);
+		} catch(Exception e) {
+			fail("Fail to instantiate exporter " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		export2.dispose();
+		foo1 = null;
+		foo2 = null;
+		export2 = null;
+	}
+	
+	public void test1() {
+		export2.start();
+		
+		// Check that no foo service are available
+		assertEquals("Check no foo service", Utils.getServiceReferences(context, FooService.class.getName(), null).length, 0);
+		
+		// Test validity
+		assertTrue("Check validity - 0", export2.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo1.stop();
+		assertTrue("Check validity - 3", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3 ("+countFooServiceProvided()+")", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 4", export2.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 5", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke());
+	}
+	
+	public void test2() {
+		export2.start();
+		
+		// Test invalidity
+		assertTrue("Check validity - 0", export2.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke());
+		
+		foo1.stop();
+		assertTrue("Check validity - 4", export2.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 5", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke());
+	}
+	
+	public void test3() {
+		foo1.start();
+		foo2.start();
+		
+		export2.start();
+		assertTrue("Check validity - 1", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo1.stop();
+		assertTrue("Check validity - 2", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export2.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 4", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke());
+	}
+	
+	public void test4() {
+		foo1.start();
+		foo2.start();
+		
+		export2.start();
+		assertTrue("Check validity - 1", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 2", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo1.stop();
+		assertTrue("Check validity - 3", export2.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 4", export2.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke());
+	}
+	
+	
+	
+	private boolean isFooServiceProvided() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export2.getInstanceName());
+		return ref != null;
+	}
+	
+	private int countFooServiceProvided() {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export2.getInstanceName()+")");
+		return refs.length;
+	}
+	
+	private boolean invoke() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export2.getInstanceName());
+		if(ref == null) { return false; }
+		BazService fs = (BazService) context.getService(ref);
+		return fs.foo();
+	}
+	
+	
+	
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalMultipleExport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalMultipleExport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalMultipleExport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/OptionalMultipleExport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,229 @@
+package org.apache.felix.ipojo.test.composite.exporter;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.BazService;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class OptionalMultipleExport extends OSGiTestCase {
+	
+	ComponentInstance export3;
+	Factory fooProvider;
+	ComponentInstance foo1 = null, foo2 = null;
+
+	public void setUp() {
+		fooProvider = Utils.getFactoryByName(context, "BazProviderType");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Fail to create foos : " + e.getMessage());
+		}
+		
+		foo1.stop();
+		foo2.stop();
+		
+		Factory factory = Utils.getFactoryByName(context, "composite.export.4");
+		Properties props = new Properties();
+		props.put("name", "export");
+		try {
+			export3 = factory.createComponentInstance(props);
+		} catch(Exception e) {
+			fail("Fail to instantiate exporter " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		export3.dispose();
+		foo1 = null;
+		foo2 = null;
+		export3 = null;
+	}
+	
+	public void test1() {
+		export3.start();
+		
+		// Check that no foo service are available
+		assertEquals("Check no foo service", Utils.getServiceReferences(context, FooService.class.getName(), null).length, 0);
+		
+		// Test invalidity
+		assertTrue("Check validity - 0", export3.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke(1));
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 2", invoke(2));
+		
+		foo1.stop();
+		assertTrue("Check validity - 3", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3 ("+countFooServiceProvided()+")", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke(1));
+		
+		foo2.stop();
+		assertTrue("Check validity - 4", export3.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 5", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke(1));
+	}
+	
+	public void test2() {
+		export3.start();
+		
+		// Test invalidity
+		assertTrue("Check validity - 0", export3.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 2", invoke(2));
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke(1));
+		
+		foo1.stop();
+		assertTrue("Check validity - 4", export3.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 5", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke(1));
+	}
+	
+	public void test3() {
+		foo1.start();
+		foo2.start();
+		
+		export3.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 1", invoke(2));
+		
+		foo1.stop();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke(1));
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export3.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 4", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke(1));
+	}
+	
+	public void test4() {
+		foo1.start();
+		foo2.start();
+		
+		export3.start();
+		assertTrue("Check validity - 1", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 2);
+		assertTrue("Check invocation - 1", invoke(2));
+		
+		foo2.stop();
+		assertTrue("Check validity - 2", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke(1));
+		
+		foo1.stop();
+		assertTrue("Check validity - 3", export3.getState() == ComponentInstance.VALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 4", export3.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke(1));
+	}
+	
+	
+	
+	private boolean isFooServiceProvided() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export3.getInstanceName());
+		return ref != null;
+	}
+	
+	private int countFooServiceProvided() {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export3.getInstanceName()+")");
+		return refs.length;
+	}
+	
+	private boolean invoke() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export3.getInstanceName());
+		if(ref == null) { return false; }
+		BazService fs = (BazService) context.getService(ref);
+		context.ungetService(ref);
+		return fs.foo();
+	}
+	
+	private boolean invoke(int nb) {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export3.getInstanceName()+")");
+		if(refs == null) { return false; }
+		if (nb > refs.length) { return false; }
+		for(int i = 0; i < nb; i++) {
+			BazService fs = (BazService) context.getService(refs[i]);
+			context.ungetService(refs[i]);
+			if(!fs.foo()) { return false; }
+		}
+		return true;
+	}
+	
+	
+	
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/SimpleExport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/SimpleExport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/SimpleExport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/exporter/SimpleExport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,216 @@
+package org.apache.felix.ipojo.test.composite.exporter;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.BazService;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class SimpleExport extends OSGiTestCase {
+	
+	ComponentInstance export1;
+	Factory fooProvider;
+	ComponentInstance foo1 = null, foo2 = null;
+
+	public void setUp() {
+		fooProvider = Utils.getFactoryByName(context, "BazProviderType");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Fail to create foos : " + e.getMessage());
+		}
+		
+		foo1.stop();
+		foo2.stop();
+		
+		Factory factory = Utils.getFactoryByName(context, "composite.export.1");
+		Properties props = new Properties();
+		props.put("name", "export");
+		try {
+			export1 = factory.createComponentInstance(props);
+		} catch(Exception e) {
+			fail("Fail to instantiate exporter " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		export1.dispose();
+		foo1 = null;
+		foo2 = null;
+		export1 = null;
+	}
+	
+	public void test1() {
+		export1.start();
+		
+		// Check that no foo service are available
+		assertEquals("Check no foo service", Utils.getServiceReferences(context, FooService.class.getName(), null).length, 0);
+		
+		// Test invalidity
+		assertTrue("Check invalidity - 0", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo1.stop();
+		assertTrue("Check validity - 3", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3 ("+countFooServiceProvided()+")", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke());
+		
+		foo2.stop();
+		assertTrue("Check invalidity - 4", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 5", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke());
+	}
+	
+	public void test2() {
+		export1.start();
+		
+		// Test invalidity
+		assertTrue("Check invalidity - 0", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 0", isFooServiceProvided());
+		assertEquals("Check number of provides - 0", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.start();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 3", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 3", invoke());
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 4", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 5", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 5", isFooServiceProvided());
+		assertEquals("Check number of provides - 5", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 5", invoke());
+	}
+	
+	public void test3() {
+		foo1.start();
+		foo2.start();
+		
+		export1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo1.stop();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo2.stop();
+		assertTrue("Check invalidity - 3", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo1.start();
+		assertTrue("Check validity - 4", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke());
+	}
+	
+	public void test4() {
+		foo1.start();
+		foo2.start();
+		
+		export1.start();
+		assertTrue("Check validity - 1", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 1", isFooServiceProvided());
+		assertEquals("Check number of provides - 1", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 1", invoke());
+		
+		foo2.stop();
+		assertTrue("Check validity - 2", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 2", isFooServiceProvided());
+		assertEquals("Check number of provides - 2", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 2", invoke());
+		
+		foo1.stop();
+		assertTrue("Check invalidity - 3", export1.getState() == ComponentInstance.INVALID);
+		assertFalse("Check providing - 3", isFooServiceProvided());
+		assertEquals("Check number of provides - 3", countFooServiceProvided(), 0);
+		
+		foo2.start();
+		assertTrue("Check validity - 4", export1.getState() == ComponentInstance.VALID);
+		assertTrue("Check providing - 4", isFooServiceProvided());
+		assertEquals("Check number of provides - 4", countFooServiceProvided(), 1);
+		assertTrue("Check invocation - 4", invoke());
+	}
+	
+	
+	
+	private boolean isFooServiceProvided() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export1.getInstanceName());
+		return ref != null;
+	}
+	
+	private int countFooServiceProvided() {
+		ServiceReference[] refs = Utils.getServiceReferences(context, BazService.class.getName(), "(instance.name="+export1.getInstanceName()+")");
+		return refs.length;
+	}
+	
+	private boolean invoke() {
+		ServiceReference ref = Utils.getServiceReferenceByName(context, BazService.class.getName(), export1.getInstanceName());
+		if(ref == null) { return false; }
+		BazService fs = (BazService) context.getService(ref);
+		return fs.foo();
+	}
+	
+	
+	
+	
+	
+
+}

Propchange: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Sun Jan 27 15:21:24 2008
@@ -0,0 +1,6 @@
+target*
+bin*
+.settings*
+.classpath
+.project
+.checkstyle

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedFilteredImport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedFilteredImport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedFilteredImport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedFilteredImport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,132 @@
+package org.apache.felix.ipojo.test.composite.importer;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.ServiceContext;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class DelayedFilteredImport extends OSGiTestCase {
+	
+	ComponentInstance import1;
+	Factory fooProvider;
+	ComponentInstance foo1, foo2;
+
+	public void setUp() {
+		
+		Properties p = new Properties();
+		p.put("name", "importer");
+		Factory compFact = Utils.getFactoryByName(context, "composite.requires.1");
+		try {
+			import1 = compFact.createComponentInstance(p);
+		} catch(Exception e) {
+			fail("Cannot instantiate the component : " + e.getMessage());
+		}
+		
+		import1.stop();
+		
+		fooProvider = Utils.getFactoryByName(context, "FooProviderType-1");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Cannot instantiate foo providers : " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		import1.dispose();
+		foo1 = null;
+		foo2 = null;
+		import1 = null;
+	}
+	
+	public void testSimple() {
+		import1.start(); 
+		//Two providers
+		assertTrue("Test component validity", import1.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import1);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		foo1.stop();
+		assertTrue("Test component validity", import1.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import1);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo2.stop();		
+		assertTrue("Test component invalidity - 2", import1.getState() == ComponentInstance.INVALID);
+		
+		foo2.start();
+		assertTrue("Test component validity", import1.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import1);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	public void testSimple2() {
+		import1.start(); 
+		//Two providers
+		assertTrue("Test component validity", import1.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import1);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		foo2.stop();
+		assertTrue("Test component validity", import1.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import1);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo1.stop();		
+		assertTrue("Test component invalidity - 2", import1.getState() == ComponentInstance.INVALID);
+		
+		foo1.start();
+		assertTrue("Test component validity", import1.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import1);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedMultipleImport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedMultipleImport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedMultipleImport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedMultipleImport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,138 @@
+package org.apache.felix.ipojo.test.composite.importer;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.ServiceContext;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class DelayedMultipleImport extends OSGiTestCase {
+	
+	ComponentInstance import2;
+	Factory fooProvider;
+	ComponentInstance foo1, foo2;
+
+	public void setUp() {
+		
+		Properties p = new Properties();
+		p.put("name", "importer");
+		Factory compFact = Utils.getFactoryByName(context, "composite.requires.2");
+		try {
+			import2 = compFact.createComponentInstance(p);
+		} catch(Exception e) {
+			fail("Cannot instantiate the component : " + e.getMessage());
+		}
+		
+		import2.stop();
+		
+		fooProvider = Utils.getFactoryByName(context, "FooProviderType-1");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Cannot instantiate foo providers : " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		import2.dispose();
+		foo1 = null;
+		foo2 = null;
+		import2 = null;
+	}
+	
+	public void testSimple() {
+		import2.start(); 
+		//Two providers
+		assertTrue("Test component validity", import2.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import2);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 2);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		fs = (FooService) sc.getService(refs[1]);
+		assertTrue("Test foo invocation (2)", fs.foo());
+		sc.ungetService(refs[1]);
+		
+		foo1.stop();
+		assertTrue("Test component validity", import2.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import2);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo2.stop();		
+		assertTrue("Test component invalidity - 2", import2.getState() == ComponentInstance.INVALID);
+		
+		foo2.start();
+		assertTrue("Test component validity", import2.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import2);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	public void testSimple2() {
+		import2.start(); 
+		//Two providers
+		assertTrue("Test component validity", import2.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import2);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 2);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		fs = (FooService) sc.getService(refs[1]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[1]);
+		
+		foo2.stop();
+		assertTrue("Test component validity", import2.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import2);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo1.stop();		
+		assertTrue("Test component invalidity - 2", import2.getState() == ComponentInstance.INVALID);
+		
+		foo1.start();
+		assertTrue("Test component validity", import2.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import2);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalImport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalImport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalImport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalImport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,138 @@
+package org.apache.felix.ipojo.test.composite.importer;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.ServiceContext;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class DelayedOptionalImport extends OSGiTestCase {
+	
+	ComponentInstance import3;
+	Factory fooProvider;
+	ComponentInstance foo1, foo2;
+
+	public void setUp() {
+		
+		Properties p = new Properties();
+		p.put("name", "importer");
+		Factory compFact = Utils.getFactoryByName(context, "composite.requires.3");
+		try {
+			import3 = compFact.createComponentInstance(p);
+		} catch(Exception e) {
+			fail("Cannot instantiate the component : " + e.getMessage());
+		}
+		
+		import3.stop();
+		
+		fooProvider = Utils.getFactoryByName(context, "FooProviderType-1");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Cannot instantiate foo providers : " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		import3.dispose();
+		foo1 = null;
+		foo2 = null;
+		import3 = null;
+	}
+	
+	public void testSimple() {
+		import3.start(); 
+		//Two providers
+		assertTrue("Test component validity", import3.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import3);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		foo1.stop();
+		assertTrue("Test component validity", import3.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import3);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo2.stop();		
+		assertTrue("Test component validity - 2", import3.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import3);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertEquals("Test foo non-availability inside the composite - 3.1", refs.length, 0);
+		
+		foo2.start();
+		assertTrue("Test component validity", import3.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import3);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	public void testSimple2() {
+		import3.start(); 
+		//Two providers
+		assertTrue("Test component validity", import3.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import3);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		foo2.stop();
+		assertTrue("Test component validity", import3.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import3);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo1.stop();		
+		assertTrue("Test component validity - 2", import3.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import3);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 0);
+		
+		foo1.start();
+		assertTrue("Test component validity", import3.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import3);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	
+
+}

Added: felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalMultipleImport.java
URL: http://svn.apache.org/viewvc/felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalMultipleImport.java?rev=615675&view=auto
==============================================================================
--- felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalMultipleImport.java (added)
+++ felix/sandbox/clement/ipojo/tests/tests.composite/src/main/java/org/apache/felix/ipojo/test/composite/importer/DelayedOptionalMultipleImport.java Sun Jan 27 15:21:24 2008
@@ -0,0 +1,144 @@
+package org.apache.felix.ipojo.test.composite.importer;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.Factory;
+import org.apache.felix.ipojo.ServiceContext;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.composite.util.Utils;
+import org.apache.felix.ipojo.test.scenarios.service.FooService;
+import org.osgi.framework.ServiceReference;
+
+public class DelayedOptionalMultipleImport extends OSGiTestCase {
+	
+	ComponentInstance import4;
+	Factory fooProvider;
+	ComponentInstance foo1, foo2;
+
+	public void setUp() {
+		
+		Properties p = new Properties();
+		p.put("name", "importer");
+		Factory compFact = Utils.getFactoryByName(context, "composite.requires.4");
+		try {
+			import4 = compFact.createComponentInstance(p);
+		} catch(Exception e) {
+			fail("Cannot instantiate the component : " + e.getMessage());
+		}
+		
+		import4.stop();
+		
+		fooProvider = Utils.getFactoryByName(context, "FooProviderType-1");
+		assertNotNull("Check fooProvider availability", fooProvider);
+		
+		Properties p1 = new Properties();
+		p1.put("name", "foo1");
+		Properties p2 = new Properties();
+		p2.put("name", "foo2");
+		try {
+			foo1 = fooProvider.createComponentInstance(p1);
+			foo2 = fooProvider.createComponentInstance(p2);
+		} catch(Exception e) {
+			fail("Cannot instantiate foo providers : " + e.getMessage());
+		}
+	}
+	
+	public void tearDown() {
+		foo1.dispose();
+		foo2.dispose();
+		import4.dispose();
+		foo1 = null;
+		foo2 = null;
+		import4 = null;
+	}
+	
+	public void testSimple() {
+		import4.start(); 
+		//Two providers
+		assertTrue("Test component validity", import4.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import4);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 2);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		fs = (FooService) sc.getService(refs[1]);
+		assertTrue("Test foo invocation (2)", fs.foo());
+		sc.ungetService(refs[1]);
+		
+		foo1.stop();
+		assertTrue("Test component validity", import4.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import4);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo2.stop();		
+		assertTrue("Test component validity - 2", import4.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import4);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertEquals("Test foo availability inside the composite - 1", refs.length, 0);
+		
+		foo2.start();
+		assertTrue("Test component validity", import4.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import4);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	public void testSimple2() {
+		import4.start(); 
+		//Two providers
+		assertTrue("Test component validity", import4.getState() == ComponentInstance.VALID);
+		ServiceContext sc = Utils.getServiceContext(import4);
+		ServiceReference[] refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 2);
+		FooService fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		fs = (FooService) sc.getService(refs[1]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[1]);
+		
+		foo2.stop();
+		assertTrue("Test component validity", import4.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import4);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 1", refs);
+		assertEquals("Test foo availability inside the composite - 1.2", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+		
+		// Stop the second provider
+		foo1.stop();		
+		assertTrue("Test component validity - 2", import4.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import4);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertEquals("Test foo availability inside the composite - 1", refs.length, 0);
+		
+		foo1.start();
+		assertTrue("Test component validity", import4.getState() == ComponentInstance.VALID);
+		sc = Utils.getServiceContext(import4);
+		refs = Utils.getServiceReferences(sc, FooService.class.getName(), null);
+		assertNotNull("Test foo availability inside the composite - 3", refs);
+		assertEquals("Test foo availability inside the composite - 3.1", refs.length, 1);
+		fs = (FooService) sc.getService(refs[0]);
+		assertTrue("Test foo invocation", fs.foo());
+		sc.ungetService(refs[0]);
+	}
+	
+	
+
+}