diff --git a/ipojo/tests/core/external-handlers/pom.xml b/ipojo/tests/core/external-handlers/pom.xml
index 8ae8e35..85140ca 100644
--- a/ipojo/tests/core/external-handlers/pom.xml
+++ b/ipojo/tests/core/external-handlers/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>
