diff --git a/ipojo/tests/core/service-dependency-comparator/pom.xml b/ipojo/tests/core/service-dependency-comparator/pom.xml
index 4d13407..58c11f2 100644
--- a/ipojo/tests/core/service-dependency-comparator/pom.xml
+++ b/ipojo/tests/core/service-dependency-comparator/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>
