diff --git a/ipojo/tests/handler/temporal/pom.xml b/ipojo/tests/handler/temporal/pom.xml
index 54fe662..5b6da51 100644
--- a/ipojo/tests/handler/temporal/pom.xml
+++ b/ipojo/tests/handler/temporal/pom.xml
@@ -45,7 +45,7 @@
 			<version>3.8.1</version>
 		</dependency>
 		<dependency>
-			<groupId>ipojo.examples</groupId>
+			<groupId>org.apache.felix</groupId>
 			<artifactId>org.apache.felix.ipojo.junit4osgi</artifactId>
 			<version>1.1.0-SNAPSHOT</version>
 		</dependency>
