diff --git a/ipojo/tests/manipulator/manipulator-java5/src/main/resources/metadata.xml b/ipojo/tests/manipulator/manipulator-java5/src/main/resources/metadata.xml
index 2c781ed..f29916c 100644
--- a/ipojo/tests/manipulator/manipulator-java5/src/main/resources/metadata.xml
+++ b/ipojo/tests/manipulator/manipulator-java5/src/main/resources/metadata.xml
@@ -1,21 +1,30 @@
-<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"
-    xmlns="org.apache.felix.ipojo"
->
+<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"
+	xmlns="org.apache.felix.ipojo">
 	
 	<!-- Check duplicate method issue -->
-	<component classname="org.apache.felix.ipojo.test.scenarios.component.PlopImpl" name="plopimpl">
+	<component classname="org.apache.felix.ipojo.test.scenarios.component.PlopImpl"
+		name="plopimpl">
 		<provides></provides>
 	</component>
-	
 	<component
 		classname="org.apache.felix.ipojo.test.scenarios.component.Manipulation23Tester"
-		name="ManipulationPrimitives5-PrimitiveManipulationTester" architecture="true">
+		name="ManipulationPrimitives5-PrimitiveManipulationTester"
+		architecture="true">
 		<provides />
 	</component>
-	
+	<component classname="org.apache.felix.ipojo.test.scenarios.component.Annotation"
+		name="Manipulation-Annotations" />
+	    
+	    
+	 <!-- Typed list -->
 	<component
-	    classname="org.apache.felix.ipojo.test.scenarios.component.Annotation"
-	    name="Manipulation-Annotations"/>
-</ipojo>
+		classname="org.apache.felix.ipojo.test.scenarios.component.FooServiceImpl">
+		<provides />
+	</component>
+	<component 
+	    classname="org.apache.felix.ipojo.test.scenarios.component.TestTypedList" name="TypedList">
+	    <provides/>
+	    <requires field="list" optional="true" specification="org.apache.felix.ipojo.test.scenarios.manipulation.service.FooService"/>
+	</component>
+</ipojo>
\ No newline at end of file
