diff --git a/ipojo/tests/manipulator/primitives/pom.xml b/ipojo/tests/manipulator/primitives/pom.xml
index f83df54..c0d4ad9 100644
--- a/ipojo/tests/manipulator/primitives/pom.xml
+++ b/ipojo/tests/manipulator/primitives/pom.xml
@@ -37,7 +37,7 @@
 		<dependency>
 			<groupId>org.apache.felix</groupId>
 			<artifactId>org.osgi.core</artifactId>
-			<version>1.2.0</version>
+			<version>1.0.1</version>
 		</dependency>
 		<dependency>
 			<groupId>junit</groupId>
