Fix issue Felix-855 and Felix-860
Felix-855:
iPOJO Temporal dependencies now support Collection. So aggregate dependencies can be injected inside collections. When using a collection, the dependency description must specify the service specification thanks to the 'specification' attribute.
Felix-860
iPOJO temporal dependencies is now able to inject proxies. So injected objects can be given to collaborators.
git-svn-id: https://svn.apache.org/repos/asf/felix/trunk@728714 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/ipojo/annotations/src/main/java/org/apache/felix/ipojo/handler/temporal/Requires.java b/ipojo/annotations/src/main/java/org/apache/felix/ipojo/handler/temporal/Requires.java
index cdf39a2..782ed7e 100644
--- a/ipojo/annotations/src/main/java/org/apache/felix/ipojo/handler/temporal/Requires.java
+++ b/ipojo/annotations/src/main/java/org/apache/felix/ipojo/handler/temporal/Requires.java
@@ -45,11 +45,24 @@
/**
* Set the on timeout action.
- * Supports null, nullable, empty-array, and default-implementation.
+ * Supports null, nullable, empty, and default-implementation.
* In this latter case, you must specify the qualified class name
* of the default-implementation (instead of default-implementation).
- * Default: no action (i.e throw a runtime exception)
+ * Default: no action (i.e throws a runtime exception)
*/
String onTimeout() default "";
+
+ /**
+ * Set the service specification (for Collection fields).
+ * This attribute is mandatory for Collections.
+ */
+ String specification() default "";
+
+ /**
+ * Inject a proxy instead of the real object.
+ * This allows passing this reference to collaborators.
+ * Default: false
+ */
+ boolean proxy() default false;
}
diff --git a/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/ServiceCollection.java b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/ServiceCollection.java
new file mode 100644
index 0000000..3369b59
--- /dev/null
+++ b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/ServiceCollection.java
@@ -0,0 +1,334 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.handler.temporal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.osgi.framework.ServiceReference;
+
+/**
+* Maintains a service object collection.
+* This collection wrap the temporal dependency to be accessible from a
+* {@link Collection}, that can be passed to helper objects (Collaborators).
+*
+* The onTimeout policies are executed when the {@link Collection#iterator()},
+* {@link Collection#toArray(Object[])} and {@link Collection#toArray()} methods
+* are called.
+*
+* The {@link Collection#iterator()} method returns an {@link Iterator} iterating
+* on a cached copy of available service objects. In the case that there are no
+* available services when the timeout is reached, the policies act as follows:
+* <ul>
+* <li>'null' returns a null iterator</li>
+* <li>'nullable' and default-implementation returns an iterator iterating on one object (the
+* nullable or default-implementation object</li>
+* <li>'empty' returns an empty iterator.</li>
+* <li>'no policy' throws runtime exception</li>
+* </ul>
+* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
+*/
+public class ServiceCollection implements Collection {
+
+ /**
+ * The wrapped temporal dependencies.
+ */
+ private TemporalDependency m_dependency;
+
+ /**
+ * Creates a Service Collection.
+ * @param dep the wrapped temporal dependencies
+ */
+ public ServiceCollection(TemporalDependency dep) {
+ m_dependency = dep;
+ }
+
+ /**
+ * Unsupported method.
+ * @param o an object
+ * @return N/A
+ * @see java.util.Collection#add(java.lang.Object)
+ */
+ public boolean add(Object o) {
+ throw new UnsupportedOperationException("Cannot add elements inside this collection");
+ }
+
+ /**
+ * Unsupported method.
+ * @param c an object
+ * @return N/A
+ * @see java.util.Collection#addAll(java.util.Collection)
+ */
+ public boolean addAll(Collection c) {
+ throw new UnsupportedOperationException("Cannot add elements inside this collection");
+ }
+
+ /**
+ * Unsupported method.
+ * @see java.util.Collection#clear()
+ */
+ public void clear() {
+ throw new UnsupportedOperationException("Cannot remove elements from this collection");
+ }
+
+ /**
+ * Checks if the wrapped temporal dependencies has always access to the
+ * given service object.The method allows knowing if the provider returning the
+ * service object has leaved.
+ * @param o the service object
+ * @return <code>true</code> if the object is still available,
+ * <code>false</code> otherwise.
+ * @see java.util.Collection#contains(java.lang.Object)
+ */
+ public boolean contains(Object o) {
+ return getAvailableObjects().contains(o);
+ }
+
+ /**
+ * Checks if the wrapped temporal dependencies has always access to the
+ * given service objects.The method allows knowing if providers returning the
+ * service objects have leaved.
+ * @param c the set of service object
+ * @return <code>true</code> if the objects are still available,
+ * <code>false</code> otherwise.
+ * @see java.util.Collection#contains(java.lang.Object)
+ */
+ public boolean containsAll(Collection c) {
+ return getAvailableObjects().containsAll(c);
+ }
+
+ /**
+ * Checks if at least one provider matching with the dependency
+ * is available.
+ * @return <code>true</code> if one provider or more satisfying the
+ * dependency are available. Otherwise, returns <code>false</code>
+ * @see java.util.Collection#isEmpty()
+ */
+ public boolean isEmpty() {
+ return m_dependency.getSize() == 0;
+ }
+
+ /**
+ * Helper method creating a list of available service objects.
+ * @return the list of available service objects.
+ */
+ private List getAvailableObjects() {
+ List list = new ArrayList();
+ ServiceReference[] refs = m_dependency.getServiceReferences();
+ if (refs != null) {
+ for (int i = 0; i < refs.length; i++) {
+ list.add(m_dependency.getService(refs[i]));
+ }
+ }
+ return list;
+ }
+
+ /**
+ * Gets an iterator on the actual list of available service objects.
+ * This method applies on timeout policies is no services are
+ * available after the timeout.
+ * The returned iterator iterates on a cached copy of the service
+ * objects.
+ * @return a iterator giving access to service objects.
+ * @see java.util.Collection#iterator()
+ */
+ public Iterator iterator() {
+ ServiceReference[] refs = m_dependency.getServiceReferences();
+ if (refs != null) {
+ // Immediate return.
+ return new ServiceIterator(refs); // Create the service iterator with the service reference list.
+ } else {
+ // Begin to wait ...
+ long enter = System.currentTimeMillis();
+ boolean exhausted = false;
+ synchronized (this) {
+ while (m_dependency.getServiceReference() == null && !exhausted) {
+ try {
+ wait(1);
+ } catch (InterruptedException e) {
+ // We was interrupted ....
+ } finally {
+ long end = System.currentTimeMillis();
+ exhausted = (end - enter) > m_dependency.getTimeout();
+ }
+ }
+ }
+ // Check
+ if (exhausted) {
+ Object oto = m_dependency.onTimeout(); // Throws the RuntimeException
+ if (oto == null) { // If null, return null
+ return null;
+ } else {
+ // oto is an instance of collection containing either empty or with only one element
+ return new ServiceIterator((Collection) oto);
+ }
+ } else {
+ refs = m_dependency.getServiceReferences();
+ return new ServiceIterator(refs);
+ }
+ }
+
+
+ }
+
+ /**
+ * Unsupported method.
+ * @param o a object
+ * @return N/A
+ * @see java.util.Collection#remove(java.lang.Object)
+ */
+ public boolean remove(Object o) {
+ throw new UnsupportedOperationException("Cannot remove elements from this collection");
+ }
+
+ /**
+ * Unsupported method.
+ * @param c a set of objects
+ * @return N/A
+ * @see java.util.Collection#removeAll(java.util.Collection)
+ */
+ public boolean removeAll(Collection c) {
+ throw new UnsupportedOperationException("Cannot remove elements from this collection");
+ }
+
+ /**
+ *Unsupported method.
+ * @param c a set of objects
+ * @return N/A
+ * @see java.util.Collection#retainAll(java.util.Collection)
+ */
+ public boolean retainAll(Collection c) {
+ throw new UnsupportedOperationException("Cannot remove elements from this collection");
+ }
+
+ /**
+ * Gets the number of available providers.
+ * @return the number of matching service providers.
+ * @see java.util.Collection#size()
+ */
+ public int size() {
+ return m_dependency.getSize();
+ }
+
+ /**
+ * Returns an array containing available service objects.
+ * This method executed on timeout policies if no matching
+ * providers when the timeout is reached.
+ * @return a array containing available service objects.
+ * depending on the timeout policy, this array can also be <code>null</code>,
+ * be empty, or can contain only one element (a default-implementation
+ * object, or a nullable object).
+ * @see java.util.Collection#toArray()
+ */
+ public Object[] toArray() {
+ return toArray(new Object[0]);
+ }
+
+ /**
+ * Returns an array containing available service objects.
+ * This method executed on timeout policies if no matching
+ * providers when the timeout is reached.
+ * @param a the array into which the elements of this collection
+ * are to be stored, if it is big enough; otherwise, a new array
+ * of the same runtime type is allocated for this purpose.
+ * @return a array containing available service objects.
+ * depending on the timeout policy, this array can also be <code>null</code>,
+ * be empty, or can contain only one element (a default-implementation
+ * object, or a nullable object).
+ * @see java.util.Collection#toArray(java.lang.Object[])
+ */
+ public Object[] toArray(Object[] a) {
+ Iterator it = iterator(); // Can throw an exception.
+ if (it == null) {
+ return null;
+ }
+ // Else we get an iterator.
+ List list = new ArrayList(size());
+ while (it.hasNext()) {
+ list.add(it.next());
+ }
+ return list.toArray(a);
+ }
+
+ /**
+ * Iterator on a set of service objects.
+ * This iterator iterates on a cached copy of service objects.
+ */
+ private final class ServiceIterator implements Iterator {
+
+ /**
+ * Underlying iterator.
+ */
+ private Iterator m_iterator;
+
+ /**
+ * Creates a Service Iterator iterating
+ * on the given set of providers.
+ * @param refs the available service providers
+ */
+ private ServiceIterator(ServiceReference[] refs) {
+ List objects = new ArrayList(refs.length);
+ for (int i = 0; i < refs.length; i++) {
+ objects.add(m_dependency.getService(refs[i]));
+ }
+ m_iterator = objects.iterator();
+ }
+
+ /**
+ * Creates a Service Iterator iterating
+ * on service object contained in the given
+ * collection.
+ * @param col a collection containing service objects.
+ */
+ private ServiceIterator(Collection col) {
+ m_iterator = col.iterator();
+ }
+
+ /**
+ * Returns <code>true</code> if the iteration has
+ * more service objects.
+ * @return <code>true</code> if the iterator has more elements.
+ * @see java.util.Iterator#hasNext()
+ */
+ public boolean hasNext() {
+ return m_iterator.hasNext();
+ }
+
+ /**
+ * Returns the next service objects in the iteration.
+ * @return the next service object in the iteration.
+ * @see java.util.Iterator#next()
+ */
+ public Object next() {
+ return m_iterator.next();
+ }
+
+ /**
+ * Unsupported operation.
+ * @see java.util.Iterator#remove()
+ */
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ }
+
+}
diff --git a/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/ServiceProxy.java b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/ServiceProxy.java
new file mode 100644
index 0000000..69aa1a4
--- /dev/null
+++ b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/ServiceProxy.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.handler.temporal;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+import org.osgi.framework.ServiceReference;
+
+/**
+ * Wrapper in front of a temporal service dependencies.
+ * This proxy can be used by collaborators. Service lookup
+ * and on timeout policies are executed when a method is invoked.
+ * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
+ */
+public class ServiceProxy implements InvocationHandler {
+
+ /**
+ * The wrapped temporal dependency.
+ */
+ private TemporalDependency m_dependency;
+
+ /**
+ * Creates a Service Proxy.
+ * @param dep the wrapped temporal dependency
+ */
+ public ServiceProxy(TemporalDependency dep) {
+ m_dependency = dep;
+ }
+
+ /**
+ * Intercept a method invocation.
+ * This method looks for a service provider, wait for timeout and
+ * depending on the lookup result either call the method
+ * on a service object or executed the on timeout policy.
+ * In this latter case, this methods can throw a {@link RuntimeException},
+ * throws a {@link NullPointerException} (null policy) or invokes the
+ * method on a nullable/default-implementation object.
+ * @param proxy the proxy on which the method is invoked
+ * @param method the invoked method
+ * @param args the arguments
+ * @return the invocation result.
+ * @throws Exception an exception occurs either during the invocation or
+ * is the result to the on timeout policy.
+ * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
+ */
+ public Object invoke(Object proxy, Method method, Object[] args)
+ throws Exception {
+ ServiceReference ref = m_dependency.getServiceReference();
+ if (ref != null) {
+ // Immediate return.
+ return invokeOperation(ref, method, args); // Invoke the method on the service object.
+ } else {
+ // Begin to wait ...
+ long enter = System.currentTimeMillis();
+ boolean exhausted = false;
+ synchronized (this) {
+ while (m_dependency.getServiceReference() == null && !exhausted) {
+ try {
+ wait(1);
+ } catch (InterruptedException e) {
+ // We was interrupted ....
+ } finally {
+ long end = System.currentTimeMillis();
+ exhausted = (end - enter) > m_dependency.getTimeout();
+ }
+ }
+ }
+ // Check
+ if (exhausted) {
+ Object oto = m_dependency.onTimeout(); // Throws the RuntimeException
+ if (oto == null) { // If null, return null
+ throw new NullPointerException("No service object available"); // throws an NPE in this case.
+ } else {
+ // invoke the method on the returned object.
+ return invokeOperation(oto, method, args);
+ }
+ } else {
+ ref = m_dependency.getServiceReference();
+ return invokeOperation(ref, method, args); // Invoke the method on the service object.
+ }
+ }
+ }
+
+ /**
+ * Helper method invoking the given method, with the given
+ * argument on the given object.
+ * @param svc the service object
+ * @param method the method object
+ * @param args the arguments
+ * @return the invocation result
+ * @throws Exception occurs when an issue happen during method invocation.
+ */
+ private Object invokeOperation(Object svc, Method method, Object[] args)
+ throws Exception {
+ return method.invoke(svc, args);
+ }
+
+ /**
+ * Helper method invoking the given method, with the given
+ * argument on the given service reference. This methods gets
+ * the service object and then invokes the method.
+ * @param ref the service reference
+ * @param method the method object
+ * @param args the arguments
+ * @return the invocation result
+ * @throws Exception occurs when an issue happen during method invocation.
+ */
+ private Object invokeOperation(ServiceReference ref, Method method, Object[] args)
+ throws Exception {
+ Object svc = m_dependency.getService(ref);
+ return method.invoke(svc, args);
+ }
+
+}
diff --git a/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalDependency.java b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalDependency.java
index a5bacfb..f0f270b 100644
--- a/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalDependency.java
+++ b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalDependency.java
@@ -20,6 +20,9 @@
import java.lang.reflect.Array;
import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
import org.apache.felix.ipojo.FieldInterceptor;
import org.apache.felix.ipojo.Nullable;
@@ -67,19 +70,32 @@
* policy (0) throw a runtime exception when the timeout occurs *
*/
private int m_policy;
+
+ /**
+ * The dependency is injected as a collection.
+ * The field must be of the {@link Collection} type
+ */
+ private boolean m_collection;
+
+ /**
+ * Enables the proxy mode.
+ */
+ private boolean m_proxy;
/**
- * Constructor.
- * @param spec service specification
+ * Creates a temporal dependency.
+ * @param spec the service specification
* @param agg is the dependency aggregate ?
- * @param filter LDAP filter
+ * @param collection the dependency field is a collection
+ * @param proxy enable the proxy-mode
+ * @param filter the LDAP filter
* @param context service context
* @param timeout timeout
* @param handler Handler managing this dependency
* @param defaultImpl class used as default-implementation
* @param policy onTimeout policy
*/
- public TemporalDependency(Class spec, boolean agg, Filter filter,
+ public TemporalDependency(Class spec, boolean agg, boolean collection, boolean proxy, Filter filter,
BundleContext context, long timeout, int policy,
String defaultImpl, TemporalHandler handler) {
super(spec, agg, true, filter, null,
@@ -88,6 +104,8 @@
m_policy = policy;
m_timeout = timeout;
m_handler = handler;
+ m_collection = collection;
+ m_proxy = proxy;
}
/**
@@ -138,21 +156,11 @@
ServiceReference[] refs = getServiceReferences();
if (refs != null) {
// Immediate return.
- if (isAggregate()) {
- Object[] svc = (Object[]) Array.newInstance(getSpecification(),
- refs.length);
- for (int i = 0; i < svc.length; i++) {
- svc[i] = getService(refs[i]);
- }
- return svc;
- } else {
- return getService(refs[0]);
- }
+ return getServiceObjects(refs);
} else {
// Begin to wait ...
long enter = System.currentTimeMillis();
boolean exhausted = false;
- ServiceReference ref = null;
synchronized (this) {
while (getServiceReference() == null && !exhausted) {
try {
@@ -169,18 +177,51 @@
if (exhausted) {
return onTimeout();
} else {
- ref = getServiceReference();
- if (isAggregate()) {
- Object[] svc = (Object[]) Array.newInstance(
- getSpecification(), 1);
- svc[0] = getService(ref);
- return svc;
- } else {
- return getService(ref);
- }
+ refs = getServiceReferences();
+ return getServiceObjects(refs);
}
}
}
+
+ /**
+ * Creates and returns object to inject in the dependency.
+ * This method handles aggregate, collection and proxy cases.
+ * @param refs the available service references
+ * @return the object to inject. Can be a 'simple' object, a proxy,
+ * a collection or an array.
+ */
+ private Object getServiceObjects(ServiceReference [] refs) {
+ if (m_proxy) {
+ if (isAggregate()) { // Necessary a collection
+ return new ServiceCollection(this);
+ } else {
+ return Proxy.newProxyInstance(m_handler
+ .getInstanceManager().getClazz().getClassLoader(),
+ new Class[] { getSpecification() },
+ new ServiceProxy(this)); // NOPMD
+ }
+ } else {
+ if (isAggregate()) {
+ if (m_collection) {
+ Collection svc = new ArrayList(refs.length); // Use an array list as collection implementation.
+ for (int i = 0; i < refs.length; i++) {
+ svc.add(getService(refs[i]));
+ }
+ return svc;
+ } else {
+ Object[] svc = (Object[]) Array.newInstance(getSpecification(),
+ refs.length);
+ for (int i = 0; i < svc.length; i++) {
+ svc[i] = getService(refs[i]);
+ }
+ return svc;
+ }
+ } else {
+ return getService(refs[0]);
+ }
+ }
+
+ }
/**
* Start method. Initializes the nullable object.
@@ -202,10 +243,16 @@
new Class[] { getSpecification(), Nullable.class },
new NullableObject()); // NOPMD
if (isAggregate()) {
- Object[] array = (Object[]) Array.newInstance(
+ if (m_collection) {
+ List list = new ArrayList(1);
+ list.add(m_nullableObject);
+ m_nullableObject = list;
+ } else {
+ Object[] array = (Object[]) Array.newInstance(
getSpecification(), 1);
- array[0] = m_nullableObject;
- m_nullableObject = array;
+ array[0] = m_nullableObject;
+ m_nullableObject = array;
+ }
}
} catch (NoClassDefFoundError e) {
// A NoClassDefFoundError is thrown if the specification
@@ -238,14 +285,24 @@
+ " : " + e.getMessage());
}
if (isAggregate()) {
- Object[] array = (Object[]) Array.newInstance(
+ if (m_collection) {
+ List list = new ArrayList(1);
+ list.add(m_nullableObject);
+ m_nullableObject = list;
+ } else {
+ Object[] array = (Object[]) Array.newInstance(
getSpecification(), 1);
- array[0] = m_nullableObject;
- m_nullableObject = array;
+ array[0] = m_nullableObject;
+ m_nullableObject = array;
+ }
}
break;
- case TemporalHandler.EMPTY_ARRAY:
- m_nullableObject = Array.newInstance(getSpecification(), 0);
+ case TemporalHandler.EMPTY:
+ if (! m_collection) {
+ m_nullableObject = Array.newInstance(getSpecification(), 0);
+ } else { // Empty collection
+ m_nullableObject = new ArrayList(0);
+ }
break;
default: // Cannot occurs
break;
@@ -275,12 +332,12 @@
* Implements the timeout policy according to the specified configuration.
* @return the object to return when the timeout occurs.
*/
- private Object onTimeout() {
+ Object onTimeout() {
switch (m_policy) {
case TemporalHandler.NULL:
case TemporalHandler.NULLABLE:
case TemporalHandler.DEFAULT_IMPLEMENTATION:
- case TemporalHandler.EMPTY_ARRAY:
+ case TemporalHandler.EMPTY:
return m_nullableObject;
default:
// Throws a runtime exception
@@ -289,5 +346,11 @@
+ " unavailable : timeout");
}
}
+
+ long getTimeout() {
+ return m_timeout;
+ }
+
+
}
diff --git a/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalHandler.java b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalHandler.java
index 24708aa..a65c616 100644
--- a/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalHandler.java
+++ b/ipojo/handler/temporal/src/main/java/org/apache/felix/ipojo/handler/temporal/TemporalHandler.java
@@ -19,6 +19,7 @@
package org.apache.felix.ipojo.handler.temporal;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Dictionary;
import java.util.List;
@@ -60,7 +61,7 @@
/**
* Uses an empty array.
*/
- public static final int EMPTY_ARRAY = 3;
+ public static final int EMPTY = 3;
/**
* Uses {@code null}.
*/
@@ -132,10 +133,27 @@
}
boolean agg = false;
+ boolean collection = false;
String spec = fieldmeta.getFieldType();
if (spec.endsWith("[]")) {
agg = true;
spec = spec.substring(0, spec.length() - 2);
+ } else if (Collection.class.getName().equals(spec)) {
+ agg = true;
+ collection = true;
+ // Collection detected. Check for the specification attribute
+ spec = deps[i].getAttribute("specification");
+ if (spec == null) {
+ error("A dependency injected inside a Collection must contain the 'specification' attribute");
+ }
+ }
+
+ String prox = deps[i].getAttribute("proxy");
+ boolean proxy = prox != null && prox.equals("true");
+ if (proxy && agg) {
+ if (! collection) {
+ error("Proxied aggregate temporal dependencies cannot be an array. Only collections are supported");
+ }
}
long timeout = DEFAULT_TIMEOUT;
@@ -154,8 +172,8 @@
if (onTimeout != null) {
if (onTimeout.equalsIgnoreCase("nullable")) {
policy = NULLABLE;
- } else if (onTimeout.equalsIgnoreCase("empty-array")) {
- policy = EMPTY_ARRAY;
+ } else if (onTimeout.equalsIgnoreCase("empty-array") || onTimeout.equalsIgnoreCase("empty")) {
+ policy = EMPTY;
if (! agg) {
// The empty array policy can only be used on aggregate dependencies
error("Cannot use the empty array policy for " + field + " : non aggregate dependency.");
@@ -169,7 +187,7 @@
}
Class specification = DependencyModel.loadSpecification(spec, getInstanceManager().getContext());
- TemporalDependency dep = new TemporalDependency(specification, agg, filter, getInstanceManager().getContext(), timeout, policy, di, this);
+ TemporalDependency dep = new TemporalDependency(specification, agg, collection, proxy, filter, getInstanceManager().getContext(), timeout, policy, di, this);
m_dependencies.add(dep);
getInstanceManager().register(fieldmeta, dep);
diff --git a/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/annotations/TemporalDependencies.java b/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/annotations/TemporalDependencies.java
index 3d692df..c364c7a 100644
--- a/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/annotations/TemporalDependencies.java
+++ b/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/annotations/TemporalDependencies.java
@@ -102,5 +102,54 @@
assertEquals("Check timeout", "100", to);
}
+
+ public void testSimpleCollection() {
+ Element meta = helper.getMetadata("org.apache.felix.ipojo.test.scenarios.component.temporal.TemporalCollection");
+ Element dep = getElementPerField(meta, "fs1");
+ String spec = dep.getAttribute("specification");
+ assertNotNull("Specification not null", spec);
+ assertEquals("Check specification", "org.apache.felix.ipojo.test.scenarios.annotations.service.FooService", spec);
+ }
+
+ public void testCollectionWithTimeout() {
+ Element meta = helper.getMetadata("org.apache.felix.ipojo.test.scenarios.component.temporal.TemporalCollection");
+ Element dep = getElementPerField(meta, "fs2");
+ String spec = dep.getAttribute("specification");
+ assertNotNull("Specification not null", spec);
+ assertEquals("Check specification", "org.apache.felix.ipojo.test.scenarios.annotations.service.FooService", spec);
+ String to = dep.getAttribute("timeout");
+ assertEquals("Check timeout", "300", to);
+ }
+
+ public void testCollectionWithPolicy() {
+ Element meta = helper.getMetadata("org.apache.felix.ipojo.test.scenarios.component.temporal.TemporalCollection");
+ Element dep = getElementPerField(meta, "fs3");
+ String spec = dep.getAttribute("specification");
+ assertNotNull("Specification not null", spec);
+ assertEquals("Check specification", "org.apache.felix.ipojo.test.scenarios.annotations.service.FooService", spec);
+ String to = dep.getAttribute("ontimeout");
+ assertEquals("Check policy", "empty", to);
+ }
+
+ public void testCollectionWithProxy() {
+ Element meta = helper.getMetadata("org.apache.felix.ipojo.test.scenarios.component.temporal.TemporalCollection");
+ Element dep = getElementPerField(meta, "fs4");
+ String spec = dep.getAttribute("specification");
+ assertNotNull("Specification not null", spec);
+ assertEquals("Check specification", "org.apache.felix.ipojo.test.scenarios.annotations.service.FooService", spec);
+ String proxy = dep.getAttribute("proxy");
+ assertEquals("Check proxy", "true", proxy);
+ }
+
+ private Element getElementPerField(Element elem, String field) {
+ Element[] provs = elem.getElements("requires", "org.apache.felix.ipojo.handler.temporal");
+ assertNotNull("Temporal exists ", provs);
+ for (int i = 0; i < provs.length; i++) {
+ if (provs[i].getAttribute("field").equals(field)) {
+ return provs[i];
+ }
+ }
+ return null;
+ }
}
diff --git a/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/component/temporal/TemporalCollection.java b/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/component/temporal/TemporalCollection.java
new file mode 100644
index 0000000..3a1143c
--- /dev/null
+++ b/ipojo/tests/core/annotations/src/main/java/org/apache/felix/ipojo/test/scenarios/component/temporal/TemporalCollection.java
@@ -0,0 +1,25 @@
+package org.apache.felix.ipojo.test.scenarios.component.temporal;
+
+import java.util.Collection;
+
+import org.apache.felix.ipojo.annotations.Component;
+import org.apache.felix.ipojo.handler.temporal.Requires;
+
+@Component
+public class TemporalCollection {
+
+ @Requires(specification="org.apache.felix.ipojo.test.scenarios.annotations.service.FooService")
+ private Collection fs1;
+
+ @Requires(specification="org.apache.felix.ipojo.test.scenarios.annotations.service.FooService", timeout=300)
+ private Collection fs2;
+
+ @Requires(onTimeout="empty", specification="org.apache.felix.ipojo.test.scenarios.annotations.service.FooService")
+ private Collection fs3;
+
+ @Requires(proxy=true, specification="org.apache.felix.ipojo.test.scenarios.annotations.service.FooService")
+ private Collection fs4;
+
+
+
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/CollectionCheckServiceProvider.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/CollectionCheckServiceProvider.java
new file mode 100644
index 0000000..03c5776
--- /dev/null
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/CollectionCheckServiceProvider.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.test.scenarios.component;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
+import org.apache.felix.ipojo.test.scenarios.temporal.service.FooService;
+
+public class CollectionCheckServiceProvider implements CheckService {
+
+ /**
+ * Temporal dependency.
+ */
+ private Collection fs;
+
+ public boolean check() {
+ boolean result = true;
+ //Use a local variable to avoid to wait at each access.
+ Collection col = fs;
+ if (col != null) {
+ Iterator it = col.iterator();
+ while (it.hasNext()) {
+ FooService svc = (FooService) it.next();
+ result = result && svc.foo();
+ }
+ }
+ return result;
+ }
+
+ public Properties getProps() {
+ Iterator it = fs.iterator();
+ if (it.hasNext()) {
+ FooService svc = (FooService) it.next();
+ return svc.fooProps();
+ }
+ return null;
+ }
+
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/CheckServiceProviderHelper.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/CheckServiceProviderHelper.java
new file mode 100755
index 0000000..cfa5b70
--- /dev/null
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/CheckServiceProviderHelper.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.test.scenarios.component.proxy;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
+import org.apache.felix.ipojo.test.scenarios.temporal.service.FooService;
+
+public class CheckServiceProviderHelper implements CheckService {
+
+ /**
+ * injected dependency.
+ */
+ private FooService fs;
+
+ public CheckServiceProviderHelper(FooService svc) {
+ fs = svc;
+ }
+
+ public boolean check() {
+ if (fs != null) { // Cannot be null
+ try {
+ return fs.foo();
+ } catch (NullPointerException e) {
+ // Can throw a NPE for null policy.
+ System.out.println(e.getMessage());
+ return false;
+ }
+ }
+ return false;
+ }
+
+ public Properties getProps() {
+ if (fs != null) {
+ return fs.fooProps();
+ }
+ return null;
+ }
+
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/CollectionCheckServiceProviderHelper.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/CollectionCheckServiceProviderHelper.java
new file mode 100644
index 0000000..9344722
--- /dev/null
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/CollectionCheckServiceProviderHelper.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.test.scenarios.component.proxy;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
+import org.apache.felix.ipojo.test.scenarios.temporal.service.FooService;
+
+public class CollectionCheckServiceProviderHelper implements CheckService {
+
+ /**
+ * Injected dependency.
+ */
+ private Collection fs;
+
+ public CollectionCheckServiceProviderHelper(Collection col) {
+ fs = col;
+ }
+
+ public boolean check() {
+ boolean result = true;
+ //Use a local variable to avoid to wait at each access.
+ Collection col = fs;
+ if (col != null) {
+ Iterator it = col.iterator(); // Get the cached copy
+ while (it != null && it.hasNext()) {
+ FooService svc = (FooService) it.next();
+ result = result && svc.foo();
+ }
+ }
+ return result;
+ }
+
+ public Properties getProps() {
+ Iterator it = fs.iterator();
+ if (it.hasNext()) {
+ FooService svc = (FooService) it.next();
+ return svc.fooProps();
+ }
+ return null;
+ }
+
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/HelpedCheckServiceProvider.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/HelpedCheckServiceProvider.java
new file mode 100755
index 0000000..f4b4099
--- /dev/null
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/HelpedCheckServiceProvider.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.test.scenarios.component.proxy;
+
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
+import org.apache.felix.ipojo.test.scenarios.temporal.service.FooService;
+
+public class HelpedCheckServiceProvider implements CheckService {
+
+ /**
+ * Temporal dependency.
+ */
+ private FooService fs;
+
+ private CheckServiceProviderHelper helper = new CheckServiceProviderHelper(fs);
+
+ public boolean check() {
+ return helper.check();
+ }
+
+ public Properties getProps() {
+ return helper.getProps();
+ }
+
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/HelpedCollectionCheckServiceProvider.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/HelpedCollectionCheckServiceProvider.java
new file mode 100644
index 0000000..f0c0e5d
--- /dev/null
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/component/proxy/HelpedCollectionCheckServiceProvider.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.test.scenarios.component.proxy;
+
+import java.util.Collection;
+import java.util.Properties;
+
+import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
+
+public class HelpedCollectionCheckServiceProvider implements CheckService {
+
+ /**
+ * Temporal dependency.
+ */
+ private Collection fs;
+
+ private CollectionCheckServiceProviderHelper helper = new CollectionCheckServiceProviderHelper(fs);
+
+ public boolean check() {
+ return helper.check();
+ }
+
+ public Properties getProps() {
+ return helper.getProps();
+ }
+
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DefaultImplementationTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DefaultImplementationTest.java
index 11a8539..bf3e7b0 100644
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DefaultImplementationTest.java
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DefaultImplementationTest.java
@@ -66,6 +66,45 @@
under.dispose();
}
+ public void testDefaultImplementationWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-DIProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
public void testDefaultImplementationTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -101,6 +140,41 @@
return;
}
+ public void testDefaultImplementationTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-DIProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A nullable was expected ...");
+ }
+ assertFalse("Check nullable", res);
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
public void testDelayTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -140,6 +214,45 @@
under.dispose();
}
+ public void testDelayTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-DIProxiedCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
public void testDefaultImplementationMultipleTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -178,6 +291,82 @@
return;
}
+ public void testDefaultImplementationCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-DIColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A nullable was expected ...");
+ }
+ assertFalse("Check nullable", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testDefaultImplementationProxiedCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-DIProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A nullable was expected ...");
+ }
+ assertFalse("Check nullable", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
public void testDelayOnMultipleDependency() {
String prov = "provider";
ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -228,4 +417,106 @@
under.stop();
under.dispose();
}
+
+ public void testDelayOnCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertFalse("Check invocation - 3", cs.check()); // Will return false as the contained DI will return false to the foo method.
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testDelayOnProxiedCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertFalse("Check invocation - 3", cs.check()); // Will return false as the contained DI will return false to the foo method.
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DelayTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DelayTest.java
index 023801b..6adb197 100644
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DelayTest.java
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/DelayTest.java
@@ -66,6 +66,45 @@
under.dispose();
}
+ public void testDelayWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
public void testTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -103,6 +142,43 @@
fail("Timeout expected");
}
+ public void testTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 4000);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ try {
+ cs.check();
+ } catch(RuntimeException e) {
+ // OK
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ fail("Timeout expected");
+ }
+
public void testDelayTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -142,6 +218,45 @@
under.dispose();
}
+ public void testDelayTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
public void testSetTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -179,6 +294,43 @@
fail("Timeout expected");
}
+ public void testSetTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ try {
+ cs.check();
+ } catch(RuntimeException e) {
+ // OK
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ fail("Timeout expected");
+ }
+
public void testDelayOnMultipleDependency() {
String prov = "provider";
ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -227,4 +379,102 @@
under.stop();
under.dispose();
}
+
+ public void testDelayOnCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ColCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider1.stop();
+ provider2.stop();
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testDelayOnProxiedCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedColCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider1.stop();
+ provider2.stop();
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/EmptyArrayTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/EmptyArrayTest.java
deleted file mode 100644
index c89456a..0000000
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/EmptyArrayTest.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.felix.ipojo.test.scenarios.temporal;
-
-import org.apache.felix.ipojo.ComponentInstance;
-import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
-import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
-import org.apache.felix.ipojo.test.scenarios.temporal.service.FooService;
-import org.apache.felix.ipojo.test.scenarios.util.Utils;
-import org.osgi.framework.ServiceReference;
-
-public class EmptyArrayTest extends OSGiTestCase {
-
- public void testEmptyArrayTimeout() {
- String prov = "provider";
- ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
- String un = "under-1";
- ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyMultipleCheckServiceProviderTimeout", un);
-
- ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
- assertNotNull("Check foo availability", ref_fs);
-
- ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
- assertNotNull("Check cs availability", ref_cs);
-
- CheckService cs = (CheckService) context.getService(ref_cs);
- assertTrue("Check invocation", cs.check());
-
- // Stop the provider.
- provider.stop();
- ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
- assertNotNull("Check cs availability - 2", ref_cs);
- DelayedProvider dp = new DelayedProvider(provider, 400);
- dp.start();
- cs = (CheckService) context.getService(ref_cs);
- boolean res = false;
- try {
- res = cs.check();
- } catch(RuntimeException e) {
- fail("An empty array was expected ...");
- }
- assertTrue("Check empty array", res);
-
- dp.stop();
- provider.stop();
- provider.dispose();
- under.stop();
- under.dispose();
- return;
- }
-
- public void testDelayOnMultipleDependency() {
- String prov = "provider";
- ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
- String prov2 = "provider2";
- ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
- String un = "under-1";
- ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyMultipleCheckServiceProvider", un);
-
- ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
- assertNotNull("Check foo availability", ref_fs);
-
- ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
- assertNotNull("Check cs availability", ref_cs);
-
- CheckService cs = (CheckService) context.getService(ref_cs);
- assertTrue("Check invocation", cs.check());
-
- // Stop the providers.
- provider1.stop();
- provider2.stop();
- ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
- assertNotNull("Check cs availability - 2", ref_cs);
- long begin = System.currentTimeMillis();
- DelayedProvider dp = new DelayedProvider(provider1, 1500);
- DelayedProvider dp2 = new DelayedProvider(provider2, 100);
- dp.start();
- dp2.start();
- cs = (CheckService) context.getService(ref_cs);
- assertTrue("Check invocation - 2", cs.check());
- long end = System.currentTimeMillis();
- System.out.println("delay = " + (end - begin));
- assertTrue("Assert min delay", (end - begin) >= 100);
- assertTrue("Assert max delay", (end - begin) <= 1000);
- dp.stop();
- dp2.stop();
-
- provider1.stop();
- provider2.stop();
-
- ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
- assertNotNull("Check cs availability - 3", ref_cs);
- cs = (CheckService) context.getService(ref_cs);
-
- assertTrue("Check invocation - 3", cs.check());
-
- provider1.dispose();
- provider2.dispose();
- under.stop();
- under.dispose();
- }
-}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/EmptyTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/EmptyTest.java
new file mode 100755
index 0000000..1ecf5bf
--- /dev/null
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/EmptyTest.java
@@ -0,0 +1,296 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.ipojo.test.scenarios.temporal;
+
+import org.apache.felix.ipojo.ComponentInstance;
+import org.apache.felix.ipojo.junit4osgi.OSGiTestCase;
+import org.apache.felix.ipojo.test.scenarios.temporal.service.CheckService;
+import org.apache.felix.ipojo.test.scenarios.temporal.service.FooService;
+import org.apache.felix.ipojo.test.scenarios.util.Utils;
+import org.osgi.framework.ServiceReference;
+
+public class EmptyTest extends OSGiTestCase {
+
+ public void testEmptyArrayTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyMultipleCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("An empty array was expected ...");
+ }
+ assertTrue("Check empty array", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testEmptyCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("An empty array was expected ...");
+ }
+ assertTrue("Check empty array", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testEmptyProxiedCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("An empty array was expected ...");
+ }
+ assertTrue("Check empty array", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testDelayOnMultipleDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyMultipleCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testDelayOnCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyColCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testDelayOnProxiedCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-EmptyProxiedColCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NoDelayTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NoDelayTest.java
index 974af3f..0e31841 100644
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NoDelayTest.java
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NoDelayTest.java
@@ -50,6 +50,29 @@
under.dispose();
}
+ public void testNoDelayWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedCheckServiceProvider", un);
+ assertNotNull("Check creation", under);
+ assertNotNull("Check provider creation", prov);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
public void testMultipleNoDelay() {
String prov1 = "provider-1";
ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov1);
@@ -70,5 +93,47 @@
under.stop();
under.dispose();
}
+
+ public void testCollectionNoDelay() {
+ String prov1 = "provider-1";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov1);
+ String un = "under-2";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ColCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov1);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ provider1.stop();
+ provider1.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testProxiedCollectionNoDelay() {
+ String prov1 = "provider-1";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov1);
+ String un = "under-2";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-ProxiedColCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov1);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ provider1.stop();
+ provider1.dispose();
+ under.stop();
+ under.dispose();
+ }
}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullTest.java
index f33c4ff..81ad5b0 100644
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullTest.java
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullTest.java
@@ -27,7 +27,7 @@
public class NullTest extends OSGiTestCase {
- public void testNullable() {
+ public void testNull() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
String un = "under-1";
@@ -66,7 +66,7 @@
under.dispose();
}
- public void testNullableTimeout() {
+ public void testNullTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
String un = "under-1";
@@ -140,7 +140,120 @@
under.dispose();
}
- public void testNullableMultipleTimeout() {
+ public void testNullWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testNullTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A null was expected ...");
+ }
+ assertFalse("Check null", res); // Return false when the foo service is null.
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testDelayTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullProxiedCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testNullMultipleTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
String un = "under-1";
@@ -178,6 +291,83 @@
return;
}
+ public void testNullCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A null was expected ...");
+ }
+ assertTrue("Check nullable", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testNullProxiedCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A null was expected ... : " + e.getMessage());
+ e.printStackTrace();
+ }
+ assertTrue("Check nullable", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
public void testDelayOnMultipleDependency() {
String prov = "provider";
ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -228,4 +418,106 @@
under.stop();
under.dispose();
}
+
+ public void testDelayOnCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertFalse("Check invocation - 3", cs.check()); // Will return false as the contained nullable will return false to the foo method.
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testDelayOnProxiedCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertFalse("Check invocation - 3", cs.check()); // Will return false as the contained nullable will return false to the foo method.
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullableTest.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullableTest.java
index b31100b..b4a4c04 100644
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullableTest.java
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/NullableTest.java
@@ -140,6 +140,119 @@
under.dispose();
}
+ public void testNullableWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testNullableTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedCheckServiceProvider", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A nullable was expected ...");
+ }
+ assertFalse("Check nullable", res);
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testDelayTimeoutWithProxy() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider, 200);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+
+ assertTrue("Assert delay", (end - begin) >= 200);
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 3", cs.check());
+
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ }
+
public void testNullableMultipleTimeout() {
String prov = "provider";
ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -178,6 +291,82 @@
return;
}
+ public void testNullableCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A nullable was expected ...");
+ }
+ assertFalse("Check nullable", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
+ public void testNullableProxiedCollectionTimeout() {
+ String prov = "provider";
+ ComponentInstance provider = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the provider.
+ provider.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ DelayedProvider dp = new DelayedProvider(provider, 400);
+ dp.start();
+ cs = (CheckService) context.getService(ref_cs);
+ boolean res = false;
+ try {
+ res = cs.check();
+ } catch(RuntimeException e) {
+ fail("A nullable was expected ...");
+ }
+ assertFalse("Check nullable", res);
+
+ dp.stop();
+ provider.stop();
+ provider.dispose();
+ under.stop();
+ under.dispose();
+ return;
+ }
+
public void testDelayOnMultipleDependency() {
String prov = "provider";
ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
@@ -228,4 +417,106 @@
under.stop();
under.dispose();
}
+
+ public void testDelayOnCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertFalse("Check invocation - 3", cs.check()); // Will return false as the contained nullable will return false to the foo method.
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
+
+ public void testDelayOnProxiedCollectionDependency() {
+ String prov = "provider";
+ ComponentInstance provider1 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov);
+ String prov2 = "provider2";
+ ComponentInstance provider2 = Utils.getComponentInstanceByName(context, "TEMPORAL-FooProvider", prov2);
+ String un = "under-1";
+ ComponentInstance under = Utils.getComponentInstanceByName(context, "TEMPORAL-NullableProxiedColCheckServiceProviderTimeout", un);
+
+ ServiceReference ref_fs = Utils.getServiceReferenceByName(context, FooService.class.getName(), prov);
+ assertNotNull("Check foo availability", ref_fs);
+
+ ServiceReference ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability", ref_cs);
+
+ CheckService cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation", cs.check());
+
+ // Stop the providers.
+ provider1.stop();
+ provider2.stop();
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 2", ref_cs);
+ long begin = System.currentTimeMillis();
+ DelayedProvider dp = new DelayedProvider(provider1, 1500);
+ DelayedProvider dp2 = new DelayedProvider(provider2, 100);
+ dp.start();
+ dp2.start();
+ cs = (CheckService) context.getService(ref_cs);
+ assertTrue("Check invocation - 2", cs.check());
+ long end = System.currentTimeMillis();
+ System.out.println("delay = " + (end - begin));
+ assertTrue("Assert min delay", (end - begin) >= 100);
+ assertTrue("Assert max delay", (end - begin) <= 1000);
+ dp.stop();
+ dp2.stop();
+
+ provider1.stop();
+ provider2.stop();
+
+ ref_cs = Utils.getServiceReferenceByName(context, CheckService.class.getName(), un);
+ assertNotNull("Check cs availability - 3", ref_cs);
+ cs = (CheckService) context.getService(ref_cs);
+
+ assertFalse("Check invocation - 3", cs.check()); // Will return false as the contained nullable will return false to the foo method.
+
+ provider1.dispose();
+ provider2.dispose();
+ under.stop();
+ under.dispose();
+ }
}
diff --git a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/TemporalTestSuite.java b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/TemporalTestSuite.java
index 7f5d1cd..a03b6a5 100644
--- a/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/TemporalTestSuite.java
+++ b/ipojo/tests/handler/temporal/src/main/java/org/apache/felix/ipojo/test/scenarios/temporal/TemporalTestSuite.java
@@ -33,7 +33,7 @@
ots.addTestSuite(NullableTest.class);
ots.addTestSuite(DefaultImplementationTest.class);
ots.addTestSuite(NullTest.class);
- ots.addTestSuite(EmptyArrayTest.class);
+ ots.addTestSuite(EmptyTest.class);
return ots;
}
diff --git a/ipojo/tests/handler/temporal/src/main/resources/metadata.xml b/ipojo/tests/handler/temporal/src/main/resources/metadata.xml
index 9613248..2ce1fbb 100644
--- a/ipojo/tests/handler/temporal/src/main/resources/metadata.xml
+++ b/ipojo/tests/handler/temporal/src/main/resources/metadata.xml
@@ -1,24 +1,40 @@
-<ipojo
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="org.apache.felix.ipojo http://people.apache.org/~clement/ipojo/schemas/core.xsd
- org.apache.felix.ipojo.handler.temporal http://people.apache.org/~clement/ipojo/schemas/temporal.xsd"
- xmlns="org.apache.felix.ipojo"
+<ipojo
xmlns:temp="org.apache.felix.ipojo.handler.temporal">
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-CheckServiceProvider">
<temp:requires field="fs"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-ProxiedCheckServiceProvider">
+ <temp:requires field="fs" proxy="true"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-CheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-ProxiedCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" timeout="300"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-MultipleCheckServiceProvider">
<temp:requires field="fs"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-ColCheckServiceProvider">
+ <temp:requires field="fs" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-ProxiedColCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.FooProvider" name="TEMPORAL-FooProvider">
<provides/>
</component>
@@ -29,71 +45,181 @@
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-NullableColCheckServiceProvider">
+ <temp:requires field="fs" onTimeout="nullable" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-NullableProxiedColCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="nullable" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-NullableCheckServiceProvider">
<temp:requires field="fs" onTimeout="nullable"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-NullableProxiedCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="nullable"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-NullableCheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="nullable"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-NullableProxiedCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" onTimeout="nullable" timeout="300"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-NullableMultipleCheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="nullable"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-NullableColCheckServiceProviderTimeout">
+ <temp:requires field="fs" onTimeout="nullable" timeout="300" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-NullableProxiedColCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" onTimeout="nullable" timeout="300" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<!-- Dependencies using default implementation -->
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-DIMultipleCheckServiceProvider">
<temp:requires field="fs" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-DIColCheckServiceProvider">
+ <temp:requires field="fs" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-DIProxiedColCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-DICheckServiceProvider">
<temp:requires field="fs" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-DIProxiedCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-DICheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-DIProxiedCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" timeout="300" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-DIMultipleCheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-DIColCheckServiceProviderTimeout">
+ <temp:requires field="fs" timeout="300" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-DIProxiedColCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" timeout="300" onTimeout="org.apache.felix.ipojo.test.scenarios.component.NullableFooProvider" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<!-- Dependencies using null -->
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-NullMultipleCheckServiceProvider">
<temp:requires field="fs" onTimeout="null"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-NullColCheckServiceProvider">
+ <temp:requires field="fs" onTimeout="null" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-NullProxiedColCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="null" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-NullCheckServiceProvider">
<temp:requires field="fs" onTimeout="null"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-NullProxiedCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="null"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.CheckServiceProvider" name="TEMPORAL-NullCheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="null"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCheckServiceProvider" name="TEMPORAL-NullProxiedCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" timeout="300" onTimeout="null"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-NullMultipleCheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="null"/>
<provides/>
</component>
- <!-- Dependencies using empty arrays -->
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-NullColCheckServiceProviderTimeout">
+ <temp:requires field="fs" timeout="300" onTimeout="null" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-NullProxiedColCheckServiceProviderTimeout">
+ <temp:requires field="fs" proxy="true" timeout="300" onTimeout="null" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <!-- Dependencies using empty arrays -->
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-EmptyMultipleCheckServiceProvider">
<temp:requires field="fs" onTimeout="empty-array"/>
<provides/>
</component>
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-EmptyColCheckServiceProvider">
+ <temp:requires field="fs" onTimeout="empty" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-EmptyProxiedColCheckServiceProvider">
+ <temp:requires field="fs" proxy="true" onTimeout="empty" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
<component classname="org.apache.felix.ipojo.test.scenarios.component.MultipleCheckServiceProvider" name="TEMPORAL-EmptyMultipleCheckServiceProviderTimeout">
<temp:requires field="fs" timeout="300" onTimeout="empty-array"/>
<provides/>
</component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.CollectionCheckServiceProvider" name="TEMPORAL-EmptyColCheckServiceProviderTimeout">
+ <temp:requires field="fs" timeout="300" onTimeout="empty" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
+
+ <component classname="org.apache.felix.ipojo.test.scenarios.component.proxy.HelpedCollectionCheckServiceProvider" name="TEMPORAL-EmptyProxiedColCheckServiceProviderTimeout">
+ <temp:requires field="fs" timeout="300" proxy="true" onTimeout="empty" specification="org.apache.felix.ipojo.test.scenarios.temporal.service.FooService"/>
+ <provides/>
+ </component>
</ipojo>
\ No newline at end of file