diff --git a/pom.xml b/pom.xml
index 710b027..8946ba3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -22,7 +22,7 @@
 		<groupId>log4j</groupId>
 		<artifactId>apache-log4j-companions-parent</artifactId>
 		<version>1.0-SNAPSHOT</version>
-		<relativePath>.../apache-log4j-companions-parent</relativePath>
+		<relativePath>../apache-log4j-companions-parent</relativePath>
 	</parent>
 	<groupId>log4j</groupId>
 	<artifactId>apache-log4j-zeroconf</artifactId>
