diff --git a/jspwiki-it-tests/jspwiki-it-test-cma-jdbc/pom.xml b/jspwiki-it-tests/jspwiki-it-test-cma-jdbc/pom.xml
index 0316af2..3a71552 100644
--- a/jspwiki-it-tests/jspwiki-it-test-cma-jdbc/pom.xml
+++ b/jspwiki-it-tests/jspwiki-it-test-cma-jdbc/pom.xml
@@ -1,79 +1,79 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent> <!-- this enables tests reuse [1/3] -->
-    <groupId>org.apache.jspwiki.it</groupId>
-    <artifactId>jspwiki-it-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <!-- Container Managed Authentication using JDBC instead of XML files for user and group info -->
-  <artifactId>jspwiki-it-test-cma-jdbc</artifactId>
-  <modelVersion>4.0.0</modelVersion>
-  <description>selenium tests execution for jspwiki-it-test-container-jdbc (container auth, relative URLs, JDBC database)</description>
-  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
-  
-  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
-               <!-- this enables tests reuse [3/3] -->
-    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
-    
-    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.JDBCGroupDatabase</it-jspwiki.groupdatabase>
-    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.JDBCUserDatabase</it-jspwiki.userdatabase>
-    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
-  </properties>
-  
-  <build>
-    <finalName>${project.artifactId}</finalName>
-    
-    <resources>
-      <resource>
-        <directory>${project.basedir}/../jspwiki-selenium-tests/src/main/resources</directory>
-        <filtering>true</filtering>
-      </resource>
-    </resources>
-    
-    <plugins>
-      <plugin>
-        <groupId>com.btmatthews.maven.plugins.inmemdb</groupId>
-        <artifactId>inmemdb-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.tomcat.maven</groupId>
-        <artifactId>tomcat7-maven-plugin</artifactId>
-        <configuration>
-          <!-- Using CMA, so Tomcat instance needs a tomcat-users.xml w/usernames & passwords -->
-          <tomcatUsers>
-            ${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat-users.xml
-          </tomcatUsers>
-          <!-- Using JDBC for User & Group info, so Tomcat instance needs JNDI lookups for database -->
-          <contextFile>${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat7-context.xml</contextFile>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>selenium-maven-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
-  
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent> <!-- this enables tests reuse [1/3] -->
+    <groupId>org.apache.jspwiki.it</groupId>
+    <artifactId>jspwiki-it-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <!-- Container Managed Authentication using JDBC instead of XML files for user and group info -->
+  <artifactId>jspwiki-it-test-cma-jdbc</artifactId>
+  <modelVersion>4.0.0</modelVersion>
+  <description>selenium tests execution for jspwiki-it-test-container-jdbc (container auth, relative URLs, JDBC database)</description>
+  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
+  
+  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
+               <!-- this enables tests reuse [3/3] -->
+    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
+    
+    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.JDBCGroupDatabase</it-jspwiki.groupdatabase>
+    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.JDBCUserDatabase</it-jspwiki.userdatabase>
+    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
+  </properties>
+  
+  <build>
+    <finalName>${project.artifactId}</finalName>
+    
+    <resources>
+      <resource>
+        <directory>${project.basedir}/../jspwiki-selenium-tests/src/main/resources</directory>
+        <filtering>true</filtering>
+      </resource>
+    </resources>
+    
+    <plugins>
+      <plugin>
+        <groupId>com.btmatthews.maven.plugins.inmemdb</groupId>
+        <artifactId>inmemdb-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.tomcat.maven</groupId>
+        <artifactId>tomcat7-maven-plugin</artifactId>
+        <configuration>
+          <!-- Using CMA, so Tomcat instance needs a tomcat-users.xml w/usernames & passwords -->
+          <tomcatUsers>
+            ${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat-users.xml
+          </tomcatUsers>
+          <!-- Using JDBC for User & Group info, so Tomcat instance needs JNDI lookups for database -->
+          <contextFile>${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat7-context.xml</contextFile>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>selenium-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+  
 </project>
\ No newline at end of file
diff --git a/jspwiki-it-tests/jspwiki-it-test-cma/pom.xml b/jspwiki-it-tests/jspwiki-it-test-cma/pom.xml
index c0cf986..1e7dff3 100644
--- a/jspwiki-it-tests/jspwiki-it-test-cma/pom.xml
+++ b/jspwiki-it-tests/jspwiki-it-test-cma/pom.xml
@@ -1,62 +1,62 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent> <!-- this enables tests reuse [1/3] -->
-    <groupId>org.apache.jspwiki.it</groupId>
-    <artifactId>jspwiki-it-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-  
-  <!-- Container Managed Authentication -->
-  <artifactId>jspwiki-it-test-cma</artifactId>
-  <modelVersion>4.0.0</modelVersion>
-  <description>selenium tests execution for jspwiki-it-test-container (container auth, relative URLs)</description>
-  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
-  
-  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
-               <!-- this enables tests reuse [3/3] -->
-    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
-    
-    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.XMLGroupDatabase</it-jspwiki.groupdatabase>
-    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.XMLUserDatabase</it-jspwiki.userdatabase>
-    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
-  </properties>
-  
-  <build>
-    <finalName>${project.artifactId}</finalName>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.tomcat.maven</groupId>
-        <artifactId>tomcat7-maven-plugin</artifactId>
-        <configuration>
-          <!-- Using CMA, so Tomcat instance needs a tomcat-users.xml w/usernames & passwords -->
-          <tomcatUsers>
-            ${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat-users.xml
-          </tomcatUsers>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>selenium-maven-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent> <!-- this enables tests reuse [1/3] -->
+    <groupId>org.apache.jspwiki.it</groupId>
+    <artifactId>jspwiki-it-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+  
+  <!-- Container Managed Authentication -->
+  <artifactId>jspwiki-it-test-cma</artifactId>
+  <modelVersion>4.0.0</modelVersion>
+  <description>selenium tests execution for jspwiki-it-test-container (container auth, relative URLs)</description>
+  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
+  
+  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
+               <!-- this enables tests reuse [3/3] -->
+    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
+    
+    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.XMLGroupDatabase</it-jspwiki.groupdatabase>
+    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.XMLUserDatabase</it-jspwiki.userdatabase>
+    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
+  </properties>
+  
+  <build>
+    <finalName>${project.artifactId}</finalName>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.tomcat.maven</groupId>
+        <artifactId>tomcat7-maven-plugin</artifactId>
+        <configuration>
+          <!-- Using CMA, so Tomcat instance needs a tomcat-users.xml w/usernames & passwords -->
+          <tomcatUsers>
+            ${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat-users.xml
+          </tomcatUsers>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>selenium-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
 </project>
\ No newline at end of file
diff --git a/jspwiki-it-tests/jspwiki-it-test-custom-absolute-urls/pom.xml b/jspwiki-it-tests/jspwiki-it-test-custom-absolute-urls/pom.xml
index 1aa1d08..4b8328d 100644
--- a/jspwiki-it-tests/jspwiki-it-test-custom-absolute-urls/pom.xml
+++ b/jspwiki-it-tests/jspwiki-it-test-custom-absolute-urls/pom.xml
@@ -1,55 +1,55 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent> <!-- this enables tests reuse [1/3] -->
-    <groupId>org.apache.jspwiki.it</groupId>
-    <artifactId>jspwiki-it-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-  
-  <artifactId>jspwiki-it-test-custom-absolute-urls</artifactId>
-  <modelVersion>4.0.0</modelVersion>
-  <description>selenium tests execution for jspwiki-it-test-custom-absolute-urls (custom auth, absolute URLs)</description>
-  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
-  
-  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
-               <!-- this enables tests reuse [3/3] -->
-    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
-    
-    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.XMLGroupDatabase</it-jspwiki.groupdatabase>
-    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.XMLUserDatabase</it-jspwiki.userdatabase>
-    <it-jspwiki.referenceStyle>absolute</it-jspwiki.referenceStyle>
-  </properties>
-  
-  <build>
-    <finalName>${project.artifactId}</finalName>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.tomcat.maven</groupId>
-        <artifactId>tomcat7-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>selenium-maven-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent> <!-- this enables tests reuse [1/3] -->
+    <groupId>org.apache.jspwiki.it</groupId>
+    <artifactId>jspwiki-it-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+  
+  <artifactId>jspwiki-it-test-custom-absolute-urls</artifactId>
+  <modelVersion>4.0.0</modelVersion>
+  <description>selenium tests execution for jspwiki-it-test-custom-absolute-urls (custom auth, absolute URLs)</description>
+  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
+  
+  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
+               <!-- this enables tests reuse [3/3] -->
+    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
+    
+    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.XMLGroupDatabase</it-jspwiki.groupdatabase>
+    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.XMLUserDatabase</it-jspwiki.userdatabase>
+    <it-jspwiki.referenceStyle>absolute</it-jspwiki.referenceStyle>
+  </properties>
+  
+  <build>
+    <finalName>${project.artifactId}</finalName>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.tomcat.maven</groupId>
+        <artifactId>tomcat7-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>selenium-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
 </project>
\ No newline at end of file
diff --git a/jspwiki-it-tests/jspwiki-it-test-custom-jdbc/pom.xml b/jspwiki-it-tests/jspwiki-it-test-custom-jdbc/pom.xml
index 2d286aa..2f3a8a2 100644
--- a/jspwiki-it-tests/jspwiki-it-test-custom-jdbc/pom.xml
+++ b/jspwiki-it-tests/jspwiki-it-test-custom-jdbc/pom.xml
@@ -1,67 +1,67 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent> <!-- this enables tests reuse [1/3] -->
-    <groupId>org.apache.jspwiki.it</groupId>
-    <artifactId>jspwiki-it-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-  
-  <artifactId>jspwiki-it-test-custom-jdbc</artifactId>
-  <modelVersion>4.0.0</modelVersion>
-  <description>selenium tests execution for jspwiki-it-test-custom (custom auth, JDBC database)</description>
-  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
-  
-  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
-               <!-- this enables tests reuse [3/3] -->
-    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
-
-    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.JDBCGroupDatabase</it-jspwiki.groupdatabase>
-    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.JDBCUserDatabase</it-jspwiki.userdatabase>
-    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
-  </properties>
-  
-  <build>
-    <finalName>${project.artifactId}</finalName>
-    
-    <plugins>
-        <plugin>
-            <groupId>com.btmatthews.maven.plugins.inmemdb</groupId>
-            <artifactId>inmemdb-maven-plugin</artifactId>
-        </plugin>
-
-        <plugin>
-            <groupId>org.apache.tomcat.maven</groupId>
-            <artifactId>tomcat7-maven-plugin</artifactId>
-            <configuration>
-              <!-- Using JDBC for User & Group info, so Tomcat instance needs JNDI lookups for database -->
-              <contextFile>${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat7-context.xml</contextFile>
-            </configuration>
-        </plugin>
-
-        <plugin>
-            <groupId>org.codehaus.mojo</groupId>
-            <artifactId>selenium-maven-plugin</artifactId>
-        </plugin>
-    </plugins>
-  </build>
-
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent> <!-- this enables tests reuse [1/3] -->
+    <groupId>org.apache.jspwiki.it</groupId>
+    <artifactId>jspwiki-it-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+  
+  <artifactId>jspwiki-it-test-custom-jdbc</artifactId>
+  <modelVersion>4.0.0</modelVersion>
+  <description>selenium tests execution for jspwiki-it-test-custom (custom auth, JDBC database)</description>
+  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
+  
+  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
+               <!-- this enables tests reuse [3/3] -->
+    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
+
+    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.JDBCGroupDatabase</it-jspwiki.groupdatabase>
+    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.JDBCUserDatabase</it-jspwiki.userdatabase>
+    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
+  </properties>
+  
+  <build>
+    <finalName>${project.artifactId}</finalName>
+    
+    <plugins>
+        <plugin>
+            <groupId>com.btmatthews.maven.plugins.inmemdb</groupId>
+            <artifactId>inmemdb-maven-plugin</artifactId>
+        </plugin>
+
+        <plugin>
+            <groupId>org.apache.tomcat.maven</groupId>
+            <artifactId>tomcat7-maven-plugin</artifactId>
+            <configuration>
+              <!-- Using JDBC for User & Group info, so Tomcat instance needs JNDI lookups for database -->
+              <contextFile>${project.basedir}/../jspwiki-selenium-tests/src/main/config/tomcatconf/tomcat7-context.xml</contextFile>
+            </configuration>
+        </plugin>
+
+        <plugin>
+            <groupId>org.codehaus.mojo</groupId>
+            <artifactId>selenium-maven-plugin</artifactId>
+        </plugin>
+    </plugins>
+  </build>
+
 </project>
\ No newline at end of file
diff --git a/jspwiki-it-tests/jspwiki-it-test-custom/pom.xml b/jspwiki-it-tests/jspwiki-it-test-custom/pom.xml
index 53a62ac..0c57877 100644
--- a/jspwiki-it-tests/jspwiki-it-test-custom/pom.xml
+++ b/jspwiki-it-tests/jspwiki-it-test-custom/pom.xml
@@ -1,56 +1,56 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent> <!-- this enables tests reuse [1/3] -->
-    <groupId>org.apache.jspwiki.it</groupId>
-    <artifactId>jspwiki-it-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-  
-  <artifactId>jspwiki-it-test-custom</artifactId>
-  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
-  <description>selenium tests execution for jspwiki-it-test-custom (custom auth, relative URLs)</description>
-
-  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
-               <!-- this enables tests reuse [3/3] -->
-    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
-
-    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.XMLGroupDatabase</it-jspwiki.groupdatabase>
-    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.XMLUserDatabase</it-jspwiki.userdatabase>
-    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
-  </properties>
-  
-  <build>
-    <finalName>${project.artifactId}</finalName>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.tomcat.maven</groupId>
-        <artifactId>tomcat7-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>selenium-maven-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent> <!-- this enables tests reuse [1/3] -->
+    <groupId>org.apache.jspwiki.it</groupId>
+    <artifactId>jspwiki-it-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+  
+  <artifactId>jspwiki-it-test-custom</artifactId>
+  <packaging>war</packaging> <!-- this enables tests reuse [2/3] -->
+  <description>selenium tests execution for jspwiki-it-test-custom (custom auth, relative URLs)</description>
+
+  <properties> <!-- values injected at jspwiki.properties & selenium templates -->
+               <!-- this enables tests reuse [3/3] -->
+    <it-jspwiki.context>${project.artifactId}</it-jspwiki.context>
+
+    <it-jspwiki.groupdatabase>org.apache.wiki.auth.authorize.XMLGroupDatabase</it-jspwiki.groupdatabase>
+    <it-jspwiki.userdatabase>org.apache.wiki.auth.user.XMLUserDatabase</it-jspwiki.userdatabase>
+    <it-jspwiki.referenceStyle>relative</it-jspwiki.referenceStyle>
+  </properties>
+  
+  <build>
+    <finalName>${project.artifactId}</finalName>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.tomcat.maven</groupId>
+        <artifactId>tomcat7-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>selenium-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
 </project>
\ No newline at end of file
diff --git a/jspwiki-it-tests/jspwiki-selenium-tests/pom.xml b/jspwiki-it-tests/jspwiki-selenium-tests/pom.xml
index 637ff96..1b64380 100644
--- a/jspwiki-it-tests/jspwiki-selenium-tests/pom.xml
+++ b/jspwiki-it-tests/jspwiki-selenium-tests/pom.xml
@@ -1,42 +1,42 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.it</groupId>
-    <artifactId>jspwiki-it-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-    <relativePath>../pom.xml</relativePath>
-  </parent>
-  
-  <artifactId>jspwiki-selenium-tests</artifactId>
-  <packaging>war</packaging>
-  <modelVersion>4.0.0</modelVersion>
-  <description>templates of selenium tests for jspwiki</description>
-  
-  <dependencies>
-    <dependency>
-      <groupId>org.apache.jspwiki</groupId>
-      <artifactId>jspwiki-war</artifactId>
-      <version>${project.version}</version>
-      <type>war</type>
-    </dependency>
-  </dependencies>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.it</groupId>
+    <artifactId>jspwiki-it-builder</artifactId>
+    <version>2.10.0</version>
+    <relativePath>../pom.xml</relativePath>
+  </parent>
+  
+  <artifactId>jspwiki-selenium-tests</artifactId>
+  <packaging>war</packaging>
+  <modelVersion>4.0.0</modelVersion>
+  <description>templates of selenium tests for jspwiki</description>
+  
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.jspwiki</groupId>
+      <artifactId>jspwiki-war</artifactId>
+      <version>${project.version}</version>
+      <type>war</type>
+    </dependency>
+  </dependencies>
 </project>
\ No newline at end of file
diff --git a/jspwiki-it-tests/pom.xml b/jspwiki-it-tests/pom.xml
index 983b58e..d0e4c1e 100644
--- a/jspwiki-it-tests/pom.xml
+++ b/jspwiki-it-tests/pom.xml
@@ -1,190 +1,190 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki</groupId>
-    <artifactId>jspwiki-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-  
-  <groupId>org.apache.jspwiki.it</groupId>
-  <artifactId>jspwiki-it-builder</artifactId>
-  <modelVersion>4.0.0</modelVersion>
-  <description>selenium tests execution for jspwiki</description>
-  <packaging>pom</packaging>
-  
-  <modules>
-    <module>jspwiki-selenium-tests</module>
-    <module>jspwiki-it-test-custom</module>
-    <module>jspwiki-it-test-custom-absolute-urls</module>
-    <module>jspwiki-it-test-custom-jdbc</module>
-    <module>jspwiki-it-test-cma</module>
-    <module>jspwiki-it-test-cma-jdbc</module>
-  </modules>
-  
-  <profiles>
-    <profile>
-      <id>integration-tests</id>
-      <build>
-        <finalName>${project.artifactId}</finalName>
-        <testResources><!-- this enables tests reuse [1/2] -->
-          <testResource>
-            <directory>${project.basedir}/../jspwiki-selenium-tests/src/test/resources</directory>
-            <filtering>true</filtering>
-          </testResource>
-        </testResources>
-
-        <resources>
-          <resource><!-- this enables tests reuse [2/2] -->
-            <directory>${project.basedir}/../jspwiki-selenium-tests/src/main/resources</directory>
-            <filtering>true</filtering>
-          </resource>
-        </resources>
-
-        <pluginManagement>
-        <plugins>
-          <plugin>
-            <artifactId>maven-war-plugin</artifactId>
-            <version>2.4</version>
-          </plugin>
-
-          <!-- Activates the HSQLDB database for IT tests -->
-          <plugin>
-            <groupId>com.btmatthews.maven.plugins.inmemdb</groupId>
-            <artifactId>inmemdb-maven-plugin</artifactId>
-            <version>1.3.0</version>
-            <configuration>
-              <monitorKey>inmem</monitorKey>
-              <monitorPort>11157</monitorPort>
-            </configuration>
-            <executions>
-              <execution>
-                <id>run</id>
-                <phase>pre-integration-test</phase>
-                <goals>
-                  <goal>run</goal>
-                </goals>
-                <configuration>
-                  <daemon>true</daemon>
-                  <type>hsqldb</type>
-                  <database>jspwiki</database>
-                  <username>sa</username>
-                  <password />
-                  <sources>
-                    <script>
-                      <sourceFile>jspwiki-selenium-tests/src/main/config/hsql-userdb-setup.sql</sourceFile>
-                    </script>
-                  </sources>
-                </configuration>
-              </execution>
-              <execution>
-                <id>stop</id>
-                <phase>post-integration-test</phase>
-                <goals>
-                  <goal>stop</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-
-            <!-- <browser>*firefox</browser> -->
-            <!-- <browser>*iexplore</browser> -->
-          <plugin>
-            <groupId>org.codehaus.mojo</groupId>
-            <artifactId>selenium-maven-plugin</artifactId>
-            <version>2.3</version>
-            <configuration>
-              <browser>*googlechrome</browser>
-              <startURL>http://localhost:8080/${project.artifactId}/</startURL>
-              <suite>target/test-classes/selenium/TestSuite.html</suite>
-              <background>true</background>
-            </configuration>
-            <executions>
-              <execution>
-                <id>test</id>
-                <phase>integration-test</phase>
-                <goals>
-                  <goal>selenese</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-
-          <!-- Additional Tomcat configuration (JNDI lookups for DB access, tomcat-users.xml file)
-               located in pom.xml of submodules using them. -->
-          <plugin>
-            <groupId>org.apache.tomcat.maven</groupId>
-            <artifactId>tomcat7-maven-plugin</artifactId>
-            <version>2.1</version>
-            <executions>
-              <execution>
-                <id>tomcat-run</id>
-                <goals>
-                  <goal>run-war</goal>
-                </goals>
-                <phase>pre-integration-test</phase>
-                <configuration>
-                  <fork>true</fork>
-                  <systemProperties>
-                    <user.language>en</user.language>
-                    <user.region>US</user.region>
-                  </systemProperties>
-                </configuration>
-              </execution>
-              <execution>
-                <id>tomcat-shutdown</id>
-                <goals>
-                  <goal>shutdown</goal>
-                </goals>
-                <phase>post-integration-test</phase>
-              </execution>
-            </executions>
-            <dependencies>
-              <dependency>
-                <groupId>org.hsqldb</groupId>
-                <artifactId>hsqldb</artifactId>
-                <version>2.3.0</version>
-              </dependency>
-            </dependencies>
-          </plugin>
-        </plugins>
-        </pluginManagement>
-      </build>
-
-      <dependencies>
-        <dependency>
-          <groupId>org.apache.jspwiki</groupId>
-          <artifactId>jspwiki-war</artifactId>
-          <version>${project.version}</version>
-          <type>war</type>
-        </dependency>
-
-        <dependency>
-          <groupId>org.seleniumhq.selenium</groupId>
-          <!-- (un)comment based on your browser preferences for tests execution -->
-          <artifactId>selenium-chrome-driver</artifactId>
-          <!-- <artifactId>selenium-ie-driver</artifactId> -->
-          <!-- <artifactId>selenium-firefox-driver</artifactId> -->
-        </dependency>
-      </dependencies>
-    </profile>
-  </profiles>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki</groupId>
+    <artifactId>jspwiki-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+  
+  <groupId>org.apache.jspwiki.it</groupId>
+  <artifactId>jspwiki-it-builder</artifactId>
+  <modelVersion>4.0.0</modelVersion>
+  <description>selenium tests execution for jspwiki</description>
+  <packaging>pom</packaging>
+  
+  <modules>
+    <module>jspwiki-selenium-tests</module>
+    <module>jspwiki-it-test-custom</module>
+    <module>jspwiki-it-test-custom-absolute-urls</module>
+    <module>jspwiki-it-test-custom-jdbc</module>
+    <module>jspwiki-it-test-cma</module>
+    <module>jspwiki-it-test-cma-jdbc</module>
+  </modules>
+  
+  <profiles>
+    <profile>
+      <id>integration-tests</id>
+      <build>
+        <finalName>${project.artifactId}</finalName>
+        <testResources><!-- this enables tests reuse [1/2] -->
+          <testResource>
+            <directory>${project.basedir}/../jspwiki-selenium-tests/src/test/resources</directory>
+            <filtering>true</filtering>
+          </testResource>
+        </testResources>
+
+        <resources>
+          <resource><!-- this enables tests reuse [2/2] -->
+            <directory>${project.basedir}/../jspwiki-selenium-tests/src/main/resources</directory>
+            <filtering>true</filtering>
+          </resource>
+        </resources>
+
+        <pluginManagement>
+        <plugins>
+          <plugin>
+            <artifactId>maven-war-plugin</artifactId>
+            <version>2.4</version>
+          </plugin>
+
+          <!-- Activates the HSQLDB database for IT tests -->
+          <plugin>
+            <groupId>com.btmatthews.maven.plugins.inmemdb</groupId>
+            <artifactId>inmemdb-maven-plugin</artifactId>
+            <version>1.3.0</version>
+            <configuration>
+              <monitorKey>inmem</monitorKey>
+              <monitorPort>11157</monitorPort>
+            </configuration>
+            <executions>
+              <execution>
+                <id>run</id>
+                <phase>pre-integration-test</phase>
+                <goals>
+                  <goal>run</goal>
+                </goals>
+                <configuration>
+                  <daemon>true</daemon>
+                  <type>hsqldb</type>
+                  <database>jspwiki</database>
+                  <username>sa</username>
+                  <password />
+                  <sources>
+                    <script>
+                      <sourceFile>jspwiki-selenium-tests/src/main/config/hsql-userdb-setup.sql</sourceFile>
+                    </script>
+                  </sources>
+                </configuration>
+              </execution>
+              <execution>
+                <id>stop</id>
+                <phase>post-integration-test</phase>
+                <goals>
+                  <goal>stop</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+
+            <!-- <browser>*firefox</browser> -->
+            <!-- <browser>*iexplore</browser> -->
+          <plugin>
+            <groupId>org.codehaus.mojo</groupId>
+            <artifactId>selenium-maven-plugin</artifactId>
+            <version>2.3</version>
+            <configuration>
+              <browser>*googlechrome</browser>
+              <startURL>http://localhost:8080/${project.artifactId}/</startURL>
+              <suite>target/test-classes/selenium/TestSuite.html</suite>
+              <background>true</background>
+            </configuration>
+            <executions>
+              <execution>
+                <id>test</id>
+                <phase>integration-test</phase>
+                <goals>
+                  <goal>selenese</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+
+          <!-- Additional Tomcat configuration (JNDI lookups for DB access, tomcat-users.xml file)
+               located in pom.xml of submodules using them. -->
+          <plugin>
+            <groupId>org.apache.tomcat.maven</groupId>
+            <artifactId>tomcat7-maven-plugin</artifactId>
+            <version>2.1</version>
+            <executions>
+              <execution>
+                <id>tomcat-run</id>
+                <goals>
+                  <goal>run-war</goal>
+                </goals>
+                <phase>pre-integration-test</phase>
+                <configuration>
+                  <fork>true</fork>
+                  <systemProperties>
+                    <user.language>en</user.language>
+                    <user.region>US</user.region>
+                  </systemProperties>
+                </configuration>
+              </execution>
+              <execution>
+                <id>tomcat-shutdown</id>
+                <goals>
+                  <goal>shutdown</goal>
+                </goals>
+                <phase>post-integration-test</phase>
+              </execution>
+            </executions>
+            <dependencies>
+              <dependency>
+                <groupId>org.hsqldb</groupId>
+                <artifactId>hsqldb</artifactId>
+                <version>2.3.0</version>
+              </dependency>
+            </dependencies>
+          </plugin>
+        </plugins>
+        </pluginManagement>
+      </build>
+
+      <dependencies>
+        <dependency>
+          <groupId>org.apache.jspwiki</groupId>
+          <artifactId>jspwiki-war</artifactId>
+          <version>${project.version}</version>
+          <type>war</type>
+        </dependency>
+
+        <dependency>
+          <groupId>org.seleniumhq.selenium</groupId>
+          <!-- (un)comment based on your browser preferences for tests execution -->
+          <artifactId>selenium-chrome-driver</artifactId>
+          <!-- <artifactId>selenium-ie-driver</artifactId> -->
+          <!-- <artifactId>selenium-firefox-driver</artifactId> -->
+        </dependency>
+      </dependencies>
+    </profile>
+  </profiles>
+</project>
diff --git a/jspwiki-war/pom.xml b/jspwiki-war/pom.xml
index 3d19d7f..7709ff6 100644
--- a/jspwiki-war/pom.xml
+++ b/jspwiki-war/pom.xml
@@ -1,351 +1,351 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki</groupId>
-    <artifactId>jspwiki-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-war</artifactId>
-  <name>Apache JSPWiki Main War</name>
-  <packaging>war</packaging>
-
-  <dependencies>
-    <dependency>
-      <groupId>xmlrpc</groupId>
-      <artifactId>xmlrpc</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.lucene</groupId>
-      <artifactId>lucene-queryparser</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.lucene</groupId>
-      <artifactId>lucene-highlighter</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.apache.lucene</groupId>
-      <artifactId>lucene-analyzers-common</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.servlet</groupId>
-      <artifactId>servlet-api</artifactId>
-      <scope>provided</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.servlet.jsp</groupId>
-      <artifactId>jsp-api</artifactId>
-      <scope>provided</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>net.sourceforge</groupId>
-      <artifactId>sandler</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>net.sf.ehcache</groupId>
-      <artifactId>ehcache-core</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>oro</groupId>
-      <artifactId>oro</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.mail</groupId>
-      <artifactId>mail</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>log4j</groupId>
-      <artifactId>log4j</artifactId>
-    </dependency>
-
-      <dependency>
-          <groupId>org.slf4j</groupId>
-          <artifactId>slf4j-log4j12</artifactId>
-      </dependency>
-
-    <dependency>
-      <groupId>com.metaparadigm</groupId>
-      <artifactId>json-rpc</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.jvnet.hudson</groupId>
-      <artifactId>org.suigeneris.jrcs.diff</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.jdom</groupId>
-      <artifactId>jdom2</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>jaxen</groupId>
-      <artifactId>jaxen</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>javax.servlet</groupId>
-      <artifactId>jstl</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>org.freshcookies</groupId>
-      <artifactId>freshcookies-security</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>ecs</groupId>
-      <artifactId>ecs</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-lang</groupId>
-      <artifactId>commons-lang</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-fileupload</groupId>
-      <artifactId>commons-fileupload</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>net.sourceforge</groupId>
-      <artifactId>akismet-java</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-httpclient</groupId>
-      <artifactId>commons-httpclient</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>commons-io</groupId>
-      <artifactId>commons-io</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>nekohtml</groupId>
-      <artifactId>nekohtml</artifactId>
-      <scope>runtime</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>net.sourceforge.stripes</groupId>
-      <artifactId>stripes</artifactId>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.hsqldb</groupId>
-      <artifactId>hsqldb</artifactId>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.hsqldb</groupId>
-      <artifactId>sqltool</artifactId>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>org.eclipse.jetty.aggregate</groupId>
-      <artifactId>jetty-all</artifactId>
-      <scope>test</scope>
-    </dependency>
-
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <finalName>JSPWiki</finalName>
-    <plugins>
-      <!-- With below plugin can deploy to an embedded Tomcat instance via:
-         mvn clean install tomcat7:run-war [-Dmaven.test.skip]
-         ...or standalone by adding a <server /> entry "myTomcat":
-         http://www.jroller.com/gmazza/entry/web_service_tutorial#maventomcat
-         and running tomcat7:redeploy instead of run-war in
-         string above.
-
-         Either way, JSPWiki URL will be
-         http://localhost:8080/JSPWiki
-      -->
-      <plugin>
-        <groupId>org.apache.tomcat.maven</groupId>
-        <artifactId>tomcat7-maven-plugin</artifactId>
-        <configuration>
-          <server>myTomcat</server>
-          <url>http://localhost:8080/manager/text</url>
-          <path>/${project.build.finalName}</path>
-        </configuration>
-      </plugin>
-
-      <!-- Surefire plugin (running unit tests):
-         http://maven.apache.org/surefire/maven-surefire-plugin/
-
-         Individual tests can be run command line via:
-         mvn clean test -Dtest=WikiEngineTest,AclImplTest,...
-
-         All tests can be skipped via -Dmaven.test.skip
-       -->
-      <plugin>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <configuration>
-          <excludes>
-            <!-- time-consuming tests excluded by default -->
-            <exclude>**/StressTestVersioningProvider.java</exclude>
-            <exclude>**/StressTestSpeed.java</exclude>
-            <exclude>**/MassiveRepositoryTest.java</exclude>
-          </excludes>
-          <includes>
-            <include>**/*Test.java</include>
-          </includes>
-        </configuration>
-      </plugin>
-
-      <!-- wro4j Web Resource Optimizer for Java (http://http://code.google.com/p/wro4j/)
-        Merge and compress CSS and JS files using the WRO4J.
-        - use UglifyJS for JS compression
-        - use Less as advanced CSS preprocessor
-      -->
-
-      <plugin>
-        <groupId>ro.isdc.wro4j</groupId>
-        <artifactId>wro4j-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <phase>prepare-package</phase>
-            <goals>
-              <goal>run</goal>
-              <!--<goal>jshint</goal>-->
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <!--
-          <targetGroups>all</targetGroups>
-          <minimize>true</minimize>
-          <cssDestinationFolder>d:/static/css/</cssDestinationFolder>
-          <jsDestinationFolder>d:/static/js/</jsDestinationFolder>
-          <ignoreMissingResources>false</ignoreMissingResources>
-          -->
-          <wroManagerFactory>ro.isdc.wro.maven.plugin.manager.factory.ConfigurableWroManagerFactory</wroManagerFactory>
-          <jsDestinationFolder>${project.build.directory}/generated-sources/wro/scripts</jsDestinationFolder>
-          <cssDestinationFolder>${project.build.directory}/generated-sources/wro/templates/default/</cssDestinationFolder>
-          <contextFolder>${basedir}/src/main/</contextFolder>
-          <wroFile>src/main/config/wro/wro.xml</wroFile>
-          <extraConfigFile>src/main/config/wro/wro.properties</extraConfigFile>
-        </configuration>
-      </plugin>
-
-      <!-- Compress certain CSS and JS files using the YUICompressor
-         (http://alchim.sourceforge.net/yuicompressor-maven-plugin/)
-      <plugin>
-        <groupId>net.alchim31.maven</groupId>
-        <artifactId>yuicompressor-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>compressJSfiles</id>
-            <goals>
-              <goal>compress</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <excludeResources>true</excludeResources>
-          <nosuffix>true</nosuffix>
-          <webappDirectory>${project.build.directory}/generated-sources/yuicompress</webappDirectory>
-          *** relying on jslint-maven-plugin instead, which allows
-               better customization ***
-          <jswarn>false</jswarn>
-        </configuration>
-      </plugin>
-      -->
-
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>jslint-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>checkJSPWikiFiles</id>
-            <goals>
-              <goal>jslint</goal>
-            </goals>
-            <configuration>
-              <sourceJsFolder>src/main/webapp/scripts</sourceJsFolder>
-              <failOnIssues>false</failOnIssues>
-              <excludes>
-                <exclude>prettify.js</exclude>
-              </excludes>
-            </configuration>
-          </execution>
-          <!-- Some third party JSs have many multiple number of VARs per function
-               block, are outside of our control so suppressing such messages -->
-          <execution>
-            <id>checkThirdParty</id>
-            <goals>
-              <goal>jslint</goal>
-            </goals>
-            <configuration>
-              <sourceJsFolder>src/main/webapp/scripts</sourceJsFolder>
-              <failOnIssues>false</failOnIssues>
-              <includes>
-                 <include>prettify.js</include>
-              </includes>
-              <allowOneVarStatementPerFunction>false</allowOneVarStatementPerFunction>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-
-      <plugin>
-        <artifactId>maven-war-plugin</artifactId>
-        <configuration>
-          <attachClasses>true</attachClasses>
-          <webResources>
-            <!-- Output directory configured above with the YUICompressor Maven plugin
-            <resource>
-              <directory>${project.build.directory}/generated-sources/yuicompress</directory>
-            </resource>
-            -->
-            <resource>
-              <directory>${project.build.directory}/generated-sources/wro</directory>
-            </resource>
-          </webResources>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki</groupId>
+    <artifactId>jspwiki-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-war</artifactId>
+  <name>Apache JSPWiki Main War</name>
+  <packaging>war</packaging>
+
+  <dependencies>
+    <dependency>
+      <groupId>xmlrpc</groupId>
+      <artifactId>xmlrpc</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.lucene</groupId>
+      <artifactId>lucene-queryparser</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.lucene</groupId>
+      <artifactId>lucene-highlighter</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.lucene</groupId>
+      <artifactId>lucene-analyzers-common</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.servlet</groupId>
+      <artifactId>servlet-api</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.servlet.jsp</groupId>
+      <artifactId>jsp-api</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>net.sourceforge</groupId>
+      <artifactId>sandler</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>net.sf.ehcache</groupId>
+      <artifactId>ehcache-core</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>oro</groupId>
+      <artifactId>oro</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.mail</groupId>
+      <artifactId>mail</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>log4j</groupId>
+      <artifactId>log4j</artifactId>
+    </dependency>
+
+      <dependency>
+          <groupId>org.slf4j</groupId>
+          <artifactId>slf4j-log4j12</artifactId>
+      </dependency>
+
+    <dependency>
+      <groupId>com.metaparadigm</groupId>
+      <artifactId>json-rpc</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.jvnet.hudson</groupId>
+      <artifactId>org.suigeneris.jrcs.diff</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.jdom</groupId>
+      <artifactId>jdom2</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>jaxen</groupId>
+      <artifactId>jaxen</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.servlet</groupId>
+      <artifactId>jstl</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.freshcookies</groupId>
+      <artifactId>freshcookies-security</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>ecs</groupId>
+      <artifactId>ecs</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>commons-lang</groupId>
+      <artifactId>commons-lang</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>commons-fileupload</groupId>
+      <artifactId>commons-fileupload</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>net.sourceforge</groupId>
+      <artifactId>akismet-java</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>commons-httpclient</groupId>
+      <artifactId>commons-httpclient</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>commons-io</groupId>
+      <artifactId>commons-io</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>nekohtml</groupId>
+      <artifactId>nekohtml</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>net.sourceforge.stripes</groupId>
+      <artifactId>stripes</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.hsqldb</groupId>
+      <artifactId>hsqldb</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.hsqldb</groupId>
+      <artifactId>sqltool</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.eclipse.jetty.aggregate</groupId>
+      <artifactId>jetty-all</artifactId>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <finalName>JSPWiki</finalName>
+    <plugins>
+      <!-- With below plugin can deploy to an embedded Tomcat instance via:
+         mvn clean install tomcat7:run-war [-Dmaven.test.skip]
+         ...or standalone by adding a <server /> entry "myTomcat":
+         http://www.jroller.com/gmazza/entry/web_service_tutorial#maventomcat
+         and running tomcat7:redeploy instead of run-war in
+         string above.
+
+         Either way, JSPWiki URL will be
+         http://localhost:8080/JSPWiki
+      -->
+      <plugin>
+        <groupId>org.apache.tomcat.maven</groupId>
+        <artifactId>tomcat7-maven-plugin</artifactId>
+        <configuration>
+          <server>myTomcat</server>
+          <url>http://localhost:8080/manager/text</url>
+          <path>/${project.build.finalName}</path>
+        </configuration>
+      </plugin>
+
+      <!-- Surefire plugin (running unit tests):
+         http://maven.apache.org/surefire/maven-surefire-plugin/
+
+         Individual tests can be run command line via:
+         mvn clean test -Dtest=WikiEngineTest,AclImplTest,...
+
+         All tests can be skipped via -Dmaven.test.skip
+       -->
+      <plugin>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <configuration>
+          <excludes>
+            <!-- time-consuming tests excluded by default -->
+            <exclude>**/StressTestVersioningProvider.java</exclude>
+            <exclude>**/StressTestSpeed.java</exclude>
+            <exclude>**/MassiveRepositoryTest.java</exclude>
+          </excludes>
+          <includes>
+            <include>**/*Test.java</include>
+          </includes>
+        </configuration>
+      </plugin>
+
+      <!-- wro4j Web Resource Optimizer for Java (http://http://code.google.com/p/wro4j/)
+        Merge and compress CSS and JS files using the WRO4J.
+        - use UglifyJS for JS compression
+        - use Less as advanced CSS preprocessor
+      -->
+
+      <plugin>
+        <groupId>ro.isdc.wro4j</groupId>
+        <artifactId>wro4j-maven-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>prepare-package</phase>
+            <goals>
+              <goal>run</goal>
+              <!--<goal>jshint</goal>-->
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <!--
+          <targetGroups>all</targetGroups>
+          <minimize>true</minimize>
+          <cssDestinationFolder>d:/static/css/</cssDestinationFolder>
+          <jsDestinationFolder>d:/static/js/</jsDestinationFolder>
+          <ignoreMissingResources>false</ignoreMissingResources>
+          -->
+          <wroManagerFactory>ro.isdc.wro.maven.plugin.manager.factory.ConfigurableWroManagerFactory</wroManagerFactory>
+          <jsDestinationFolder>${project.build.directory}/generated-sources/wro/scripts</jsDestinationFolder>
+          <cssDestinationFolder>${project.build.directory}/generated-sources/wro/templates/default/</cssDestinationFolder>
+          <contextFolder>${basedir}/src/main/</contextFolder>
+          <wroFile>src/main/config/wro/wro.xml</wroFile>
+          <extraConfigFile>src/main/config/wro/wro.properties</extraConfigFile>
+        </configuration>
+      </plugin>
+
+      <!-- Compress certain CSS and JS files using the YUICompressor
+         (http://alchim.sourceforge.net/yuicompressor-maven-plugin/)
+      <plugin>
+        <groupId>net.alchim31.maven</groupId>
+        <artifactId>yuicompressor-maven-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>compressJSfiles</id>
+            <goals>
+              <goal>compress</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <excludeResources>true</excludeResources>
+          <nosuffix>true</nosuffix>
+          <webappDirectory>${project.build.directory}/generated-sources/yuicompress</webappDirectory>
+          *** relying on jslint-maven-plugin instead, which allows
+               better customization ***
+          <jswarn>false</jswarn>
+        </configuration>
+      </plugin>
+      -->
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>jslint-maven-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>checkJSPWikiFiles</id>
+            <goals>
+              <goal>jslint</goal>
+            </goals>
+            <configuration>
+              <sourceJsFolder>src/main/webapp/scripts</sourceJsFolder>
+              <failOnIssues>false</failOnIssues>
+              <excludes>
+                <exclude>prettify.js</exclude>
+              </excludes>
+            </configuration>
+          </execution>
+          <!-- Some third party JSs have many multiple number of VARs per function
+               block, are outside of our control so suppressing such messages -->
+          <execution>
+            <id>checkThirdParty</id>
+            <goals>
+              <goal>jslint</goal>
+            </goals>
+            <configuration>
+              <sourceJsFolder>src/main/webapp/scripts</sourceJsFolder>
+              <failOnIssues>false</failOnIssues>
+              <includes>
+                 <include>prettify.js</include>
+              </includes>
+              <allowOneVarStatementPerFunction>false</allowOneVarStatementPerFunction>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <artifactId>maven-war-plugin</artifactId>
+        <configuration>
+          <attachClasses>true</attachClasses>
+          <webResources>
+            <!-- Output directory configured above with the YUICompressor Maven plugin
+            <resource>
+              <directory>${project.build.directory}/generated-sources/yuicompress</directory>
+            </resource>
+            -->
+            <resource>
+              <directory>${project.build.directory}/generated-sources/wro</directory>
+            </resource>
+          </webResources>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/jspwiki-wikipages/de/pom.xml b/jspwiki-wikipages/de/pom.xml
index b98de04..d011f5a 100644
--- a/jspwiki-wikipages/de/pom.xml
+++ b/jspwiki-wikipages/de/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-de</artifactId>
-  <name>Apache JSPWiki initial wiki pages (de)</name>
-  
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-de</artifactId>
+  <name>Apache JSPWiki initial wiki pages (de)</name>
+  
+</project>
diff --git a/jspwiki-wikipages/en/pom.xml b/jspwiki-wikipages/en/pom.xml
index bc84b15..65c896d 100644
--- a/jspwiki-wikipages/en/pom.xml
+++ b/jspwiki-wikipages/en/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-en</artifactId>
-  <name>Apache JSPWiki initial wiki pages (en)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-en</artifactId>
+  <name>Apache JSPWiki initial wiki pages (en)</name>
+
+</project>
diff --git a/jspwiki-wikipages/es/pom.xml b/jspwiki-wikipages/es/pom.xml
index 4164580..d5f0a32 100644
--- a/jspwiki-wikipages/es/pom.xml
+++ b/jspwiki-wikipages/es/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-es</artifactId>
-  <name>Apache JSPWiki initial wiki pages (es)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-es</artifactId>
+  <name>Apache JSPWiki initial wiki pages (es)</name>
+
+</project>
diff --git a/jspwiki-wikipages/fi/pom.xml b/jspwiki-wikipages/fi/pom.xml
index 6f4c5a1..13e86b7 100644
--- a/jspwiki-wikipages/fi/pom.xml
+++ b/jspwiki-wikipages/fi/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-fi</artifactId>
-  <name>Apache JSPWiki initial wiki pages (fi)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-fi</artifactId>
+  <name>Apache JSPWiki initial wiki pages (fi)</name>
+
+</project>
diff --git a/jspwiki-wikipages/fr/pom.xml b/jspwiki-wikipages/fr/pom.xml
index ea7b1e6..0edd4e1 100644
--- a/jspwiki-wikipages/fr/pom.xml
+++ b/jspwiki-wikipages/fr/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-fr</artifactId>
-  <name>Apache JSPWiki initial wiki pages (fr)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-fr</artifactId>
+  <name>Apache JSPWiki initial wiki pages (fr)</name>
+
+</project>
diff --git a/jspwiki-wikipages/it/pom.xml b/jspwiki-wikipages/it/pom.xml
index 9b26bcc..82acf9d 100644
--- a/jspwiki-wikipages/it/pom.xml
+++ b/jspwiki-wikipages/it/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-it</artifactId>
-  <name>Apache JSPWiki initial wiki pages (it)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-it</artifactId>
+  <name>Apache JSPWiki initial wiki pages (it)</name>
+
+</project>
diff --git a/jspwiki-wikipages/nl/pom.xml b/jspwiki-wikipages/nl/pom.xml
index 3fd832f..f531e73 100644
--- a/jspwiki-wikipages/nl/pom.xml
+++ b/jspwiki-wikipages/nl/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-nl</artifactId>
-  <name>Apache JSPWiki initial wiki pages (nl)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-nl</artifactId>
+  <name>Apache JSPWiki initial wiki pages (nl)</name>
+
+</project>
diff --git a/jspwiki-wikipages/pom.xml b/jspwiki-wikipages/pom.xml
index 11b4c71..daeffd0 100644
--- a/jspwiki-wikipages/pom.xml
+++ b/jspwiki-wikipages/pom.xml
@@ -1,45 +1,45 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki</groupId>
-    <artifactId>jspwiki-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-builder</artifactId>
-  <groupId>org.apache.jspwiki.wikipages</groupId>
-  <name>Apache JSPWiki initial wiki pages builder</name>
-  <packaging>pom</packaging>
-
-  <modules>
-    <module>de</module>
-    <module>en</module>
-    <module>es</module>
-    <module>fi</module>
-    <module>fr</module>
-    <module>it</module>
-    <module>nl</module>
-    <module>pt_BR</module>
-    <module>zh_CN</module>
-  </modules>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki</groupId>
+    <artifactId>jspwiki-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-builder</artifactId>
+  <groupId>org.apache.jspwiki.wikipages</groupId>
+  <name>Apache JSPWiki initial wiki pages builder</name>
+  <packaging>pom</packaging>
+
+  <modules>
+    <module>de</module>
+    <module>en</module>
+    <module>es</module>
+    <module>fi</module>
+    <module>fr</module>
+    <module>it</module>
+    <module>nl</module>
+    <module>pt_BR</module>
+    <module>zh_CN</module>
+  </modules>
+</project>
diff --git a/jspwiki-wikipages/pt_BR/pom.xml b/jspwiki-wikipages/pt_BR/pom.xml
index 6364036..6ed3155 100644
--- a/jspwiki-wikipages/pt_BR/pom.xml
+++ b/jspwiki-wikipages/pt_BR/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-pt_BR</artifactId>
-  <name>Apache JSPWiki initial wiki pages (pt_BR)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-pt_BR</artifactId>
+  <name>Apache JSPWiki initial wiki pages (pt_BR)</name>
+
+</project>
diff --git a/jspwiki-wikipages/zh_CN/pom.xml b/jspwiki-wikipages/zh_CN/pom.xml
index aac401d..1c9a51a 100644
--- a/jspwiki-wikipages/zh_CN/pom.xml
+++ b/jspwiki-wikipages/zh_CN/pom.xml
@@ -1,32 +1,32 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache.jspwiki.wikipages</groupId>
-    <artifactId>jspwiki-wikipages-builder</artifactId>
-    <version>2.10.0-SNAPSHOT</version>
-  </parent>
-
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>jspwiki-wikipages-zh_CN</artifactId>
-  <name>Apache JSPWiki initial wiki pages (zh_CN)</name>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache.jspwiki.wikipages</groupId>
+    <artifactId>jspwiki-wikipages-builder</artifactId>
+    <version>2.10.0</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>jspwiki-wikipages-zh_CN</artifactId>
+  <name>Apache JSPWiki initial wiki pages (zh_CN)</name>
+
+</project>
diff --git a/pom.xml b/pom.xml
index 59d27c1..a633a63 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,692 +1,692 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-    Licensed to the Apache Software Foundation (ASF) under one
-    or more contributor license agreements.  See the NOTICE file
-    distributed with this work for additional information
-    regarding copyright ownership.  The ASF licenses this file
-    to you under the Apache License, Version 2.0 (the
-    "License"); you may not use this file except in compliance
-    with the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing,
-    software distributed under the License is distributed on an
-    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, either express or implied.  See the License for the
-    specific language governing permissions and limitations
-    under the License.
---><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
-  <parent>
-    <groupId>org.apache</groupId>
-    <artifactId>apache</artifactId>
-    <version>13</version>
-  </parent>
-
-  <groupId>org.apache.jspwiki</groupId>
-  <artifactId>jspwiki-builder</artifactId>
-  <modelVersion>4.0.0</modelVersion>
-  <name>Apache JSPWiki</name>
-  <version>2.10.0-SNAPSHOT</version>
-  <packaging>pom</packaging>
-  <description>Apache JSPWiki is a leading open source WikiWiki engine, feature-rich
-    and built around standard J2EE components (Java, servlets, JSP).</description>
-  <url>http://jspwiki.apache.org/</url>
-
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-    <jdk.version>1.6</jdk.version>
-    <lucene.version>4.6.0</lucene.version>
-  </properties>
-
-  <prerequisites>
-    <maven>3.0.4</maven>
-  </prerequisites>
-
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/jspwiki/trunk</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/jspwiki/trunk</developerConnection>
-    <url>http://svn.apache.org/viewvc/jspwiki/trunk</url>
-  </scm>
-
-  <modules>
-    <module>jspwiki-war</module>
-    <module>jspwiki-wikipages</module>
-    <module>jspwiki-it-tests</module><!-- IT tests are launched only if -Pintegration-tests is given -->
-  </modules>
-
-  <dependencyManagement> <!-- defines what configuration is going to be used if, and only if, the dependency is used -->
-    <dependencies>       <!-- ordered alphabetically by scope:groupId:artifactId                                     -->
-      <!-- compile dependencies -->
-      <dependency>
-        <groupId>com.metaparadigm</groupId>
-        <artifactId>json-rpc</artifactId>
-        <version>1.0</version>
-      </dependency>
-
-      <dependency>
-        <groupId>commons-fileupload</groupId>
-        <artifactId>commons-fileupload</artifactId>
-        <version>1.3</version>
-      </dependency>
-
-      <dependency>
-        <groupId>commons-httpclient</groupId>
-        <artifactId>commons-httpclient</artifactId>
-        <version>3.1</version>
-      </dependency>
-
-      <dependency>
-        <groupId>commons-io</groupId>
-        <artifactId>commons-io</artifactId>
-        <version>2.4</version>
-      </dependency>
-
-      <dependency>
-        <groupId>commons-lang</groupId>
-        <artifactId>commons-lang</artifactId>
-        <version>2.6</version>
-      </dependency>
-
-      <dependency>
-        <groupId>ecs</groupId>
-        <artifactId>ecs</artifactId>
-        <version>1.4.2</version>
-      </dependency>
-
-      <dependency>
-        <groupId>javax.mail</groupId>
-        <artifactId>mail</artifactId>
-        <version>1.4.7</version>
-      </dependency>
-
-      <dependency>
-        <groupId>javax.servlet</groupId>
-        <artifactId>jstl</artifactId>
-        <version>1.2</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.jdom</groupId>
-        <artifactId>jdom2</artifactId>
-        <version>2.0.5</version>
-      </dependency>
-
-      <dependency>
-        <groupId>jaxen</groupId>
-        <artifactId>jaxen</artifactId>
-        <version>1.1.4</version>
-      </dependency>
-
-      <dependency>
-        <groupId>log4j</groupId>
-        <artifactId>log4j</artifactId>
-        <version>1.2.17</version>
-      </dependency>
-
-      <dependency>
-         <groupId>org.slf4j</groupId>
-         <artifactId>slf4j-log4j12</artifactId>
-         <version>1.7.2</version>
-       </dependency>
-
-        <dependency>
-        <groupId>net.sourceforge</groupId>
-        <artifactId>akismet-java</artifactId>
-        <version>1.02</version>
-      </dependency>
-
-      <dependency>
-        <groupId>net.sourceforge</groupId>
-        <artifactId>sandler</artifactId>
-        <version>0.5</version>
-      </dependency>
-
-      <dependency>
-        <groupId>net.sf.ehcache</groupId>
-        <artifactId>ehcache-core</artifactId>
-        <version>2.6.6</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.apache.lucene</groupId>
-        <artifactId>lucene-queryparser</artifactId>
-        <version>${lucene.version}</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.apache.lucene</groupId>
-        <artifactId>lucene-highlighter</artifactId>
-        <version>${lucene.version}</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.apache.lucene</groupId>
-        <artifactId>lucene-analyzers-common</artifactId>
-        <scope>compile</scope>
-        <version>${lucene.version}</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.freshcookies</groupId>
-        <artifactId>freshcookies-security</artifactId>
-        <version>0.60</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.jvnet.hudson</groupId>
-        <artifactId>org.suigeneris.jrcs.diff</artifactId>
-        <version>0.4.2</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.seleniumhq.selenium</groupId>
-        <artifactId>selenium-chrome-driver</artifactId>
-        <version>2.33.0</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.seleniumhq.selenium</groupId>
-        <artifactId>selenium-firefox-driver</artifactId>
-        <version>2.33.0</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.seleniumhq.selenium</groupId>
-        <artifactId>selenium-ie-driver</artifactId>
-        <version>2.33.0</version>
-      </dependency>
-
-      <dependency>
-        <groupId>oro</groupId>
-        <artifactId>oro</artifactId>
-        <version>2.0.8</version>
-      </dependency>
-
-      <dependency>
-        <groupId>xmlrpc</groupId>
-        <artifactId>xmlrpc</artifactId>
-        <version>2.0.1</version>
-      </dependency>
-
-      <!-- test dependencies -->
-      <dependency>
-        <groupId>junit</groupId>
-        <artifactId>junit</artifactId>
-        <version>4.11</version>
-      </dependency>
-
-      <dependency>
-        <groupId>net.sourceforge.stripes</groupId>
-        <artifactId>stripes</artifactId>
-        <version>1.5.7</version>
-      </dependency>
-
-      <!--
-           Note: As Jetty activates during the build, can upgrade
-           only to the latest Jetty version that can run on the
-           minimum JDK JSPWiki supports:
-           http://www.eclipse.org/jetty/documentation/current/what-jetty-version.html
-      -->
-      <dependency>
-        <groupId>org.eclipse.jetty.aggregate</groupId>
-        <artifactId>jetty-all</artifactId>
-        <version>8.1.12.v20130726</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.hsqldb</groupId>
-        <artifactId>hsqldb</artifactId>
-        <version>2.3.0</version>
-      </dependency>
-
-      <dependency>
-        <groupId>org.hsqldb</groupId>
-        <artifactId>sqltool</artifactId>
-        <version>2.3.0</version>
-      </dependency>
-
-      <!-- provided dependencies -->
-      <dependency>
-        <groupId>javax.servlet.jsp</groupId>
-        <artifactId>jsp-api</artifactId>
-        <version>2.1</version>
-      </dependency>
-
-      <dependency>
-        <groupId>javax.servlet</groupId>
-        <artifactId>servlet-api</artifactId>
-        <version>2.5</version>
-      </dependency>
-
-      <!-- runtime dependencies -->
-      <dependency>
-        <groupId>nekohtml</groupId>
-        <artifactId>nekohtml</artifactId>
-        <version>0.9.5</version>
-      </dependency>
-    </dependencies>
-  </dependencyManagement>
-
-  <build>
-    <plugins>  <!-- plugins executed with every build -->
-      <plugin>
-        <artifactId>maven-enforcer-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>enforcer-validations</id>
-            <goals><goal>enforce</goal></goals>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-
-    <pluginManagement> <!-- defines what configuration is going to be used if, and only if, the plugin is used                          -->
-      <plugins>        <!-- ordered alphabetically by groupId (default first):artifactId                                                -->
-        <plugin>       <!-- default maven plugins have their version configured to make the build independent of the maven version used -->
-          <artifactId>maven-antrun-plugin</artifactId>
-          <version>1.7</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-assembly-plugin</artifactId>
-          <version>2.4</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-clean-plugin</artifactId>
-          <version>2.5</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-compiler-plugin</artifactId>
-          <version>3.1</version>
-          <configuration>
-            <encoding>${project.build.sourceEncoding}</encoding>
-            <source>${jdk.version}</source>
-            <target>${jdk.version}</target>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-eclipse-plugin</artifactId>
-          <version>2.9</version>
-          <configuration>
-            <downloadSources>true</downloadSources>
-            <downloadJavadocs>true</downloadJavadocs>
-            <additionalConfig>
-              <file>
-                <name>.checkstyle</name>
-                <location>./jspwiki-war/src/main/config/dev/jspwiki-checkstyle.xml</location>
-              </file>
-              <file>
-                <name>.settings/org.eclipse.jdt.core.prefs</name>
-                <location>./jspwiki-war/src/main/config/dev/jspwiki-eclipse-codestyle.xml</location>
-              </file>
-            </additionalConfig>
-            <additionalProjectnatures>
-              <projectnature>net.sourceforge.metrics.nature</projectnature>
-              <projectnature>net.sf.eclipsecs.core.CheckstyleNature</projectnature>
-            </additionalProjectnatures>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <groupId>org.apache.maven.plugins</groupId>
-          <artifactId>maven-idea-plugin</artifactId>
-          <version>2.2.1</version>
-          <configuration>
-            <downloadSources>true</downloadSources>
-            <downloadJavadocs>true</downloadJavadocs>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-enforcer-plugin</artifactId>
-          <version>1.3.1</version>
-          <configuration>
-            <fail>true</fail>
-            <rules>
-              <requireJavaVersion>
-                <message>MUST USE JDK 1.6</message>
-                <version>${jdk.version}</version>
-              </requireJavaVersion>
-              <requireMavenVersion>
-                <message>BUILD REQUIRES MAVEN 3</message>
-                <version>[3.0,)</version>
-              </requireMavenVersion>
-            </rules>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-jar-plugin</artifactId>
-          <version>2.4</version>
-          <configuration>
-            <archive>
-              <manifest>
-                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
-                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-              </manifest>
-              <manifestEntries>
-                <Extension-Name>${project.artifactId}</Extension-Name>
-              </manifestEntries>
-            </archive>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-install-plugin</artifactId>
-          <version>2.5.1</version>
-          <configuration>
-            <createChecksum>true</createChecksum>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-javadoc-plugin</artifactId>
-          <version>2.9.1</version>
-          <configuration>
-            <additionalparam>
-            -charset ${project.build.sourceEncoding}
-            -docencoding ${project.build.sourceEncoding}
-            -version
-            -author
-            -breakiterator
-            -linksource
-            -sourcetab 4
-            -windowtitle "${project.name} ${project.version}"
-            -bottom ""
-            -doctitle "${project.name} ${project.version}"
-            -link {project.organization.url}
-            </additionalparam>
-            <bottom>Copyright © {inceptionYear}-{currentYear} ${project.organization.name}. All rights reserved.</bottom>
-            <doclet>org.jboss.apiviz.APIviz</doclet>
-            <docletArtifact>
-              <groupId>org.jboss.apiviz</groupId>
-              <artifactId>apiviz</artifactId>
-              <version>1.3.2.GA</version>
-            </docletArtifact>
-            <encoding>${project.build.sourceEncoding}</encoding>
-            <quiet>true</quiet>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-jxr-plugin</artifactId>
-          <version>2.3</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-project-info-reports-plugin</artifactId>
-          <version>2.7</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-resources-plugin</artifactId>
-          <version>2.6</version>
-          <configuration>
-            <encoding>${project.build.sourceEncoding}</encoding>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-source-plugin</artifactId>
-          <version>2.2.1</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-surefire-plugin</artifactId>
-          <version>2.16</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-surefire-report-plugin</artifactId>
-          <version>2.16</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-war-plugin</artifactId>
-          <version>2.4</version>
-          <configuration>
-            <archive>
-              <manifest>
-                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
-                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-              </manifest>
-              <manifestEntries>
-                <Extension-Name>${project.artifactId}</Extension-Name>
-                <Implementation-Version>${project.version}</Implementation-Version>
-                <Specification-Version>${project.version}</Specification-Version>
-              </manifestEntries>
-            </archive>
-            <archiveClasses>true</archiveClasses>
-          </configuration>
-        </plugin>
-
-        <!-- wro4j Web Resource Optimizer for Java (http://http://code.google.com/p/wro4j/)
-          Merge and compress CSS and JS files using the WRO4J.
-          - use UglifyJS for JS compression
-          - use Less as advanced CSS preprocessor
-        -->
-
-        <plugin>
-          <groupId>ro.isdc.wro4j</groupId>
-          <artifactId>wro4j-maven-plugin</artifactId>
-          <version>1.7.2</version>
-        </plugin>
-
-        <!-- yuicompressor  => replaced by wro4j
-        <plugin>
-          <groupId>net.alchim31.maven</groupId>
-          <artifactId>yuicompressor-maven-plugin</artifactId>
-          <version>1.3.2</version>
-        </plugin>
-        -->
-
-        <plugin>
-          <groupId>org.codehaus.mojo</groupId>
-          <artifactId>jslint-maven-plugin</artifactId>
-          <version>1.0.1</version>
-        </plugin>
-
-        <plugin>
-          <groupId>org.apache.rat</groupId>
-          <artifactId>apache-rat-plugin</artifactId>
-          <version>0.10</version>
-          <configuration>
-            <excludes>
-              <exclude>mvn_cheat-sheet.txt</exclude> <!-- handy list of maven commands; will be moved to site once we've switched to Maven -->
-              <exclude>**/src/main/config/doc/LICENSE.*</exclude>    <!-- 3rd party License files -->
-              <exclude>**/src/main/config/wikipages/**</exclude>     <!-- Default wikipages -->
-              <exclude>**/src/main/config/dev/OldChangeLog</exclude> <!-- ChangeLog excluded by default, this is, well, an old ChangeLog -->
-              <exclude>**/src/main/webapp/scripts/*.js</exclude>     <!-- minified files -->
-              <exclude>**/src/test/resources/TextFormattingRules.txt</exclude> <!-- test input data -->
-              <exclude>**/src/test/resources/test-repo/*.txt</exclude> <!-- web tests input data -->
-              <exclude>**/src/main/webapp/templates/default/images/SilkIconSet-readme.txt</exclude> <!-- license, required by Silk Icon set cfr. NOTICE, LICENSE, etc. -->
-            </excludes>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <groupId>org.apache.tomcat.maven</groupId>
-          <artifactId>tomcat7-maven-plugin</artifactId>
-          <version>2.2</version>
-          <configuration>
-            <contextReloadable>true</contextReloadable>
-            <port>8080</port>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <groupId>org.codehaus.mojo</groupId>
-          <artifactId>clirr-maven-plugin</artifactId>
-          <version>2.6.1</version>
-        </plugin>
-
-        <plugin>
-          <groupId>org.codehaus.mojo</groupId>
-          <artifactId>cobertura-maven-plugin</artifactId>
-          <version>2.6</version>
-          <configuration>
-            <formats>
-              <format>html</format>
-              <format>xml</format>
-            </formats>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <groupId>org.codehaus.mojo</groupId>
-          <artifactId>selenium-maven-plugin</artifactId>
-          <version>2.3</version>
-          <configuration>
-            <background>true</background>
-          </configuration>
-        </plugin>
-
-        <plugin>
-          <groupId>org.codehaus.mojo</groupId>
-          <artifactId>sonar-maven-plugin</artifactId>
-          <version>2.2</version>
-        </plugin>
-
-        <plugin>
-          <groupId>org.codehaus.sonar-plugins</groupId>
-          <artifactId>maven-report</artifactId>
-          <version>0.1</version>
-        </plugin>
-
-        <!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
-        <plugin>
-          <groupId>org.eclipse.m2e</groupId>
-          <artifactId>lifecycle-mapping</artifactId>
-          <version>1.0.0</version>
-          <configuration>
-            <lifecycleMappingMetadata>
-              <pluginExecutions>
-                <pluginExecution>
-                  <pluginExecutionFilter>
-                    <groupId>net.alchim31.maven</groupId>
-                    <artifactId>yuicompressor-maven-plugin</artifactId>
-                    <versionRange>[1.3.2,)</versionRange>
-                    <goals><goal>compress</goal></goals>
-                  </pluginExecutionFilter>
-                  <action><ignore /></action>
-                </pluginExecution>
-                <pluginExecution>
-                  <pluginExecutionFilter>
-                    <groupId>org.apache.maven.plugins</groupId>
-                    <artifactId>maven-antrun-plugin</artifactId>
-                    <versionRange>[1.7,)</versionRange>
-                    <goals><goal>run</goal></goals>
-                  </pluginExecutionFilter>
-                  <action><ignore /></action>
-                </pluginExecution>
-                <pluginExecution>
-                  <pluginExecutionFilter>
-                    <groupId>org.codehaus.mojo</groupId>
-                    <artifactId>jslint-maven-plugin</artifactId>
-                    <versionRange>[1.0.1,)</versionRange>
-                    <goals><goal>jslint</goal></goals>
-                  </pluginExecutionFilter>
-                  <action><ignore /></action>
-                </pluginExecution>
-                <pluginExecution>
-                  <pluginExecutionFilter>
-                    <groupId>ro.isdc.wro4j</groupId>
-                    <artifactId>wro4j-maven-plugin</artifactId>
-                    <versionRange>[1.7.2,)</versionRange>
-                    <goals><goal>run</goal></goals>
-                  </pluginExecutionFilter>
-                  <action><ignore /></action>
-                </pluginExecution>
-              </pluginExecutions>
-            </lifecycleMappingMetadata>
-          </configuration>
-        </plugin>
-      </plugins>
-    </pluginManagement>
-  </build>
-
-  <profiles>
-    <profile>
-      <id>build-wikipages-zip</id>
-      <activation>
-        <file>
-          <exists>../assembly/zip.xml</exists>
-        </file>
-      </activation>
-      <build>       <!-- apache-release from project's parent pom enables assembly plugin on all modules, so to build the -->
-        <plugins>   <!-- wikipages zip we must fall back to invoke it on each wikipage submodule. In order to reuse some  -->
-          <plugin>  <!-- build logic, we use a custom profile. Cfr with property on each jspwiki-wikipages submodule.     -->
-            <artifactId>maven-assembly-plugin</artifactId>
-            <executions>
-              <execution>
-                <id>create-wikipages-zip</id>
-                <phase>package</phase>
-                <goals><goal>single</goal></goals>
-                <configuration>
-                  <appendAssemblyId>false</appendAssemblyId>
-                  <descriptors>
-                    <descriptor>../assembly/zip.xml</descriptor>
-                  </descriptors>
-                </configuration>
-              </execution>
-            </executions>
-          </plugin>
-        </plugins>
-      </build>
-    </profile>
-  </profiles>
-  
-  <organization>
-    <name>The Apache Software Foundation</name>
-    <url>http://www.apache.org/</url>
-  </organization>
-
-  <licenses>
-    <license>
-      <name>The Apache Software License, Version 2.0</name>
-      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <mailingLists>
-    <mailingList>
-      <name>Apache JSPWiki-dev List</name>
-      <subscribe>dev-subscribe@jspwiki.apache.org</subscribe>
-      <unsubscribe>dev-unsubscribe@jspwiki.apache.org</unsubscribe>
-      <post>dev@jspwiki.apache.org</post>
-      <archive>http://mail-archives.apache.org/mod_mbox/jspwiki-dev/</archive>
-    </mailingList>
-
-    <mailingList>
-      <name>Apache JSPWiki-user List</name>
-      <subscribe>user-subscribe@jspwiki.apache.org</subscribe>
-      <unsubscribe>user-unsubscribe@jspwiki.apache.org</unsubscribe>
-      <post>user@jspwiki.apache.org</post>
-      <archive>http://mail-archives.apache.org/mod_mbox/jspwiki-user/</archive>
-    </mailingList>
-
-    <mailingList>
-      <name>Apache JSPWiki-commits List</name>
-      <subscribe>commits-subscribe@jspwiki.apache.org</subscribe>
-      <unsubscribe>commits-unsubscribe@jspwiki.apache.org</unsubscribe>
-      <archive>http://mail-archives.apache.org/mod_mbox/jspwiki-commits/</archive>
-    </mailingList>
-  </mailingLists>
-
-  <issueManagement>
-    <system>JIRA</system>
-    <url>http://issues.apache.org/jira/browse/JSPWIKI</url>
-  </issueManagement>
-
-  <ciManagement>
-    <system>Jenkins</system>
-    <url>https://builds.apache.org/job/JSPWiki</url>
-  </ciManagement>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+--><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.apache</groupId>
+    <artifactId>apache</artifactId>
+    <version>13</version>
+  </parent>
+
+  <groupId>org.apache.jspwiki</groupId>
+  <artifactId>jspwiki-builder</artifactId>
+  <modelVersion>4.0.0</modelVersion>
+  <name>Apache JSPWiki</name>
+  <version>2.10.0</version>
+  <packaging>pom</packaging>
+  <description>Apache JSPWiki is a leading open source WikiWiki engine, feature-rich
+    and built around standard J2EE components (Java, servlets, JSP).</description>
+  <url>http://jspwiki.apache.org/</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+    <jdk.version>1.6</jdk.version>
+    <lucene.version>4.6.0</lucene.version>
+  </properties>
+
+  <prerequisites>
+    <maven>3.0.4</maven>
+  </prerequisites>
+
+  <scm>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/jspwiki/tags/jspwiki_2_10_0_rc2</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/jspwiki/tags/jspwiki_2_10_0_rc2</developerConnection>
+    <url>http://svn.apache.org/viewvc/jspwiki/tags/jspwiki_2_10_0_rc2</url>
+  </scm>
+
+  <modules>
+    <module>jspwiki-war</module>
+    <module>jspwiki-wikipages</module>
+    <module>jspwiki-it-tests</module><!-- IT tests are launched only if -Pintegration-tests is given -->
+  </modules>
+
+  <dependencyManagement> <!-- defines what configuration is going to be used if, and only if, the dependency is used -->
+    <dependencies>       <!-- ordered alphabetically by scope:groupId:artifactId                                     -->
+      <!-- compile dependencies -->
+      <dependency>
+        <groupId>com.metaparadigm</groupId>
+        <artifactId>json-rpc</artifactId>
+        <version>1.0</version>
+      </dependency>
+
+      <dependency>
+        <groupId>commons-fileupload</groupId>
+        <artifactId>commons-fileupload</artifactId>
+        <version>1.3</version>
+      </dependency>
+
+      <dependency>
+        <groupId>commons-httpclient</groupId>
+        <artifactId>commons-httpclient</artifactId>
+        <version>3.1</version>
+      </dependency>
+
+      <dependency>
+        <groupId>commons-io</groupId>
+        <artifactId>commons-io</artifactId>
+        <version>2.4</version>
+      </dependency>
+
+      <dependency>
+        <groupId>commons-lang</groupId>
+        <artifactId>commons-lang</artifactId>
+        <version>2.6</version>
+      </dependency>
+
+      <dependency>
+        <groupId>ecs</groupId>
+        <artifactId>ecs</artifactId>
+        <version>1.4.2</version>
+      </dependency>
+
+      <dependency>
+        <groupId>javax.mail</groupId>
+        <artifactId>mail</artifactId>
+        <version>1.4.7</version>
+      </dependency>
+
+      <dependency>
+        <groupId>javax.servlet</groupId>
+        <artifactId>jstl</artifactId>
+        <version>1.2</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.jdom</groupId>
+        <artifactId>jdom2</artifactId>
+        <version>2.0.5</version>
+      </dependency>
+
+      <dependency>
+        <groupId>jaxen</groupId>
+        <artifactId>jaxen</artifactId>
+        <version>1.1.4</version>
+      </dependency>
+
+      <dependency>
+        <groupId>log4j</groupId>
+        <artifactId>log4j</artifactId>
+        <version>1.2.17</version>
+      </dependency>
+
+      <dependency>
+         <groupId>org.slf4j</groupId>
+         <artifactId>slf4j-log4j12</artifactId>
+         <version>1.7.2</version>
+       </dependency>
+
+        <dependency>
+        <groupId>net.sourceforge</groupId>
+        <artifactId>akismet-java</artifactId>
+        <version>1.02</version>
+      </dependency>
+
+      <dependency>
+        <groupId>net.sourceforge</groupId>
+        <artifactId>sandler</artifactId>
+        <version>0.5</version>
+      </dependency>
+
+      <dependency>
+        <groupId>net.sf.ehcache</groupId>
+        <artifactId>ehcache-core</artifactId>
+        <version>2.6.6</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.apache.lucene</groupId>
+        <artifactId>lucene-queryparser</artifactId>
+        <version>${lucene.version}</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.apache.lucene</groupId>
+        <artifactId>lucene-highlighter</artifactId>
+        <version>${lucene.version}</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.apache.lucene</groupId>
+        <artifactId>lucene-analyzers-common</artifactId>
+        <scope>compile</scope>
+        <version>${lucene.version}</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.freshcookies</groupId>
+        <artifactId>freshcookies-security</artifactId>
+        <version>0.60</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.jvnet.hudson</groupId>
+        <artifactId>org.suigeneris.jrcs.diff</artifactId>
+        <version>0.4.2</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.seleniumhq.selenium</groupId>
+        <artifactId>selenium-chrome-driver</artifactId>
+        <version>2.33.0</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.seleniumhq.selenium</groupId>
+        <artifactId>selenium-firefox-driver</artifactId>
+        <version>2.33.0</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.seleniumhq.selenium</groupId>
+        <artifactId>selenium-ie-driver</artifactId>
+        <version>2.33.0</version>
+      </dependency>
+
+      <dependency>
+        <groupId>oro</groupId>
+        <artifactId>oro</artifactId>
+        <version>2.0.8</version>
+      </dependency>
+
+      <dependency>
+        <groupId>xmlrpc</groupId>
+        <artifactId>xmlrpc</artifactId>
+        <version>2.0.1</version>
+      </dependency>
+
+      <!-- test dependencies -->
+      <dependency>
+        <groupId>junit</groupId>
+        <artifactId>junit</artifactId>
+        <version>4.11</version>
+      </dependency>
+
+      <dependency>
+        <groupId>net.sourceforge.stripes</groupId>
+        <artifactId>stripes</artifactId>
+        <version>1.5.7</version>
+      </dependency>
+
+      <!--
+           Note: As Jetty activates during the build, can upgrade
+           only to the latest Jetty version that can run on the
+           minimum JDK JSPWiki supports:
+           http://www.eclipse.org/jetty/documentation/current/what-jetty-version.html
+      -->
+      <dependency>
+        <groupId>org.eclipse.jetty.aggregate</groupId>
+        <artifactId>jetty-all</artifactId>
+        <version>8.1.12.v20130726</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.hsqldb</groupId>
+        <artifactId>hsqldb</artifactId>
+        <version>2.3.0</version>
+      </dependency>
+
+      <dependency>
+        <groupId>org.hsqldb</groupId>
+        <artifactId>sqltool</artifactId>
+        <version>2.3.0</version>
+      </dependency>
+
+      <!-- provided dependencies -->
+      <dependency>
+        <groupId>javax.servlet.jsp</groupId>
+        <artifactId>jsp-api</artifactId>
+        <version>2.1</version>
+      </dependency>
+
+      <dependency>
+        <groupId>javax.servlet</groupId>
+        <artifactId>servlet-api</artifactId>
+        <version>2.5</version>
+      </dependency>
+
+      <!-- runtime dependencies -->
+      <dependency>
+        <groupId>nekohtml</groupId>
+        <artifactId>nekohtml</artifactId>
+        <version>0.9.5</version>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <build>
+    <plugins>  <!-- plugins executed with every build -->
+      <plugin>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <executions>
+          <execution>
+            <id>enforcer-validations</id>
+            <goals><goal>enforce</goal></goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+
+    <pluginManagement> <!-- defines what configuration is going to be used if, and only if, the plugin is used                          -->
+      <plugins>        <!-- ordered alphabetically by groupId (default first):artifactId                                                -->
+        <plugin>       <!-- default maven plugins have their version configured to make the build independent of the maven version used -->
+          <artifactId>maven-antrun-plugin</artifactId>
+          <version>1.7</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-assembly-plugin</artifactId>
+          <version>2.4</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-clean-plugin</artifactId>
+          <version>2.5</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-compiler-plugin</artifactId>
+          <version>3.1</version>
+          <configuration>
+            <encoding>${project.build.sourceEncoding}</encoding>
+            <source>${jdk.version}</source>
+            <target>${jdk.version}</target>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-eclipse-plugin</artifactId>
+          <version>2.9</version>
+          <configuration>
+            <downloadSources>true</downloadSources>
+            <downloadJavadocs>true</downloadJavadocs>
+            <additionalConfig>
+              <file>
+                <name>.checkstyle</name>
+                <location>./jspwiki-war/src/main/config/dev/jspwiki-checkstyle.xml</location>
+              </file>
+              <file>
+                <name>.settings/org.eclipse.jdt.core.prefs</name>
+                <location>./jspwiki-war/src/main/config/dev/jspwiki-eclipse-codestyle.xml</location>
+              </file>
+            </additionalConfig>
+            <additionalProjectnatures>
+              <projectnature>net.sourceforge.metrics.nature</projectnature>
+              <projectnature>net.sf.eclipsecs.core.CheckstyleNature</projectnature>
+            </additionalProjectnatures>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-idea-plugin</artifactId>
+          <version>2.2.1</version>
+          <configuration>
+            <downloadSources>true</downloadSources>
+            <downloadJavadocs>true</downloadJavadocs>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-enforcer-plugin</artifactId>
+          <version>1.3.1</version>
+          <configuration>
+            <fail>true</fail>
+            <rules>
+              <requireJavaVersion>
+                <message>MUST USE JDK 1.6</message>
+                <version>${jdk.version}</version>
+              </requireJavaVersion>
+              <requireMavenVersion>
+                <message>BUILD REQUIRES MAVEN 3</message>
+                <version>[3.0,)</version>
+              </requireMavenVersion>
+            </rules>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-jar-plugin</artifactId>
+          <version>2.4</version>
+          <configuration>
+            <archive>
+              <manifest>
+                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+              </manifest>
+              <manifestEntries>
+                <Extension-Name>${project.artifactId}</Extension-Name>
+              </manifestEntries>
+            </archive>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-install-plugin</artifactId>
+          <version>2.5.1</version>
+          <configuration>
+            <createChecksum>true</createChecksum>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-javadoc-plugin</artifactId>
+          <version>2.9.1</version>
+          <configuration>
+            <additionalparam>
+            -charset ${project.build.sourceEncoding}
+            -docencoding ${project.build.sourceEncoding}
+            -version
+            -author
+            -breakiterator
+            -linksource
+            -sourcetab 4
+            -windowtitle "${project.name} ${project.version}"
+            -bottom ""
+            -doctitle "${project.name} ${project.version}"
+            -link {project.organization.url}
+            </additionalparam>
+            <bottom>Copyright © {inceptionYear}-{currentYear} ${project.organization.name}. All rights reserved.</bottom>
+            <doclet>org.jboss.apiviz.APIviz</doclet>
+            <docletArtifact>
+              <groupId>org.jboss.apiviz</groupId>
+              <artifactId>apiviz</artifactId>
+              <version>1.3.2.GA</version>
+            </docletArtifact>
+            <encoding>${project.build.sourceEncoding}</encoding>
+            <quiet>true</quiet>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-jxr-plugin</artifactId>
+          <version>2.3</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-project-info-reports-plugin</artifactId>
+          <version>2.7</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-resources-plugin</artifactId>
+          <version>2.6</version>
+          <configuration>
+            <encoding>${project.build.sourceEncoding}</encoding>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-source-plugin</artifactId>
+          <version>2.2.1</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-surefire-plugin</artifactId>
+          <version>2.16</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-surefire-report-plugin</artifactId>
+          <version>2.16</version>
+        </plugin>
+
+        <plugin>
+          <artifactId>maven-war-plugin</artifactId>
+          <version>2.4</version>
+          <configuration>
+            <archive>
+              <manifest>
+                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+              </manifest>
+              <manifestEntries>
+                <Extension-Name>${project.artifactId}</Extension-Name>
+                <Implementation-Version>${project.version}</Implementation-Version>
+                <Specification-Version>${project.version}</Specification-Version>
+              </manifestEntries>
+            </archive>
+            <archiveClasses>true</archiveClasses>
+          </configuration>
+        </plugin>
+
+        <!-- wro4j Web Resource Optimizer for Java (http://http://code.google.com/p/wro4j/)
+          Merge and compress CSS and JS files using the WRO4J.
+          - use UglifyJS for JS compression
+          - use Less as advanced CSS preprocessor
+        -->
+
+        <plugin>
+          <groupId>ro.isdc.wro4j</groupId>
+          <artifactId>wro4j-maven-plugin</artifactId>
+          <version>1.7.2</version>
+        </plugin>
+
+        <!-- yuicompressor  => replaced by wro4j
+        <plugin>
+          <groupId>net.alchim31.maven</groupId>
+          <artifactId>yuicompressor-maven-plugin</artifactId>
+          <version>1.3.2</version>
+        </plugin>
+        -->
+
+        <plugin>
+          <groupId>org.codehaus.mojo</groupId>
+          <artifactId>jslint-maven-plugin</artifactId>
+          <version>1.0.1</version>
+        </plugin>
+
+        <plugin>
+          <groupId>org.apache.rat</groupId>
+          <artifactId>apache-rat-plugin</artifactId>
+          <version>0.10</version>
+          <configuration>
+            <excludes>
+              <exclude>mvn_cheat-sheet.txt</exclude> <!-- handy list of maven commands; will be moved to site once we've switched to Maven -->
+              <exclude>**/src/main/config/doc/LICENSE.*</exclude>    <!-- 3rd party License files -->
+              <exclude>**/src/main/config/wikipages/**</exclude>     <!-- Default wikipages -->
+              <exclude>**/src/main/config/dev/OldChangeLog</exclude> <!-- ChangeLog excluded by default, this is, well, an old ChangeLog -->
+              <exclude>**/src/main/webapp/scripts/*.js</exclude>     <!-- minified files -->
+              <exclude>**/src/test/resources/TextFormattingRules.txt</exclude> <!-- test input data -->
+              <exclude>**/src/test/resources/test-repo/*.txt</exclude> <!-- web tests input data -->
+              <exclude>**/src/main/webapp/templates/default/images/SilkIconSet-readme.txt</exclude> <!-- license, required by Silk Icon set cfr. NOTICE, LICENSE, etc. -->
+            </excludes>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <groupId>org.apache.tomcat.maven</groupId>
+          <artifactId>tomcat7-maven-plugin</artifactId>
+          <version>2.2</version>
+          <configuration>
+            <contextReloadable>true</contextReloadable>
+            <port>8080</port>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <groupId>org.codehaus.mojo</groupId>
+          <artifactId>clirr-maven-plugin</artifactId>
+          <version>2.6.1</version>
+        </plugin>
+
+        <plugin>
+          <groupId>org.codehaus.mojo</groupId>
+          <artifactId>cobertura-maven-plugin</artifactId>
+          <version>2.6</version>
+          <configuration>
+            <formats>
+              <format>html</format>
+              <format>xml</format>
+            </formats>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <groupId>org.codehaus.mojo</groupId>
+          <artifactId>selenium-maven-plugin</artifactId>
+          <version>2.3</version>
+          <configuration>
+            <background>true</background>
+          </configuration>
+        </plugin>
+
+        <plugin>
+          <groupId>org.codehaus.mojo</groupId>
+          <artifactId>sonar-maven-plugin</artifactId>
+          <version>2.2</version>
+        </plugin>
+
+        <plugin>
+          <groupId>org.codehaus.sonar-plugins</groupId>
+          <artifactId>maven-report</artifactId>
+          <version>0.1</version>
+        </plugin>
+
+        <!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
+        <plugin>
+          <groupId>org.eclipse.m2e</groupId>
+          <artifactId>lifecycle-mapping</artifactId>
+          <version>1.0.0</version>
+          <configuration>
+            <lifecycleMappingMetadata>
+              <pluginExecutions>
+                <pluginExecution>
+                  <pluginExecutionFilter>
+                    <groupId>net.alchim31.maven</groupId>
+                    <artifactId>yuicompressor-maven-plugin</artifactId>
+                    <versionRange>[1.3.2,)</versionRange>
+                    <goals><goal>compress</goal></goals>
+                  </pluginExecutionFilter>
+                  <action><ignore /></action>
+                </pluginExecution>
+                <pluginExecution>
+                  <pluginExecutionFilter>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-antrun-plugin</artifactId>
+                    <versionRange>[1.7,)</versionRange>
+                    <goals><goal>run</goal></goals>
+                  </pluginExecutionFilter>
+                  <action><ignore /></action>
+                </pluginExecution>
+                <pluginExecution>
+                  <pluginExecutionFilter>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>jslint-maven-plugin</artifactId>
+                    <versionRange>[1.0.1,)</versionRange>
+                    <goals><goal>jslint</goal></goals>
+                  </pluginExecutionFilter>
+                  <action><ignore /></action>
+                </pluginExecution>
+                <pluginExecution>
+                  <pluginExecutionFilter>
+                    <groupId>ro.isdc.wro4j</groupId>
+                    <artifactId>wro4j-maven-plugin</artifactId>
+                    <versionRange>[1.7.2,)</versionRange>
+                    <goals><goal>run</goal></goals>
+                  </pluginExecutionFilter>
+                  <action><ignore /></action>
+                </pluginExecution>
+              </pluginExecutions>
+            </lifecycleMappingMetadata>
+          </configuration>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+  </build>
+
+  <profiles>
+    <profile>
+      <id>build-wikipages-zip</id>
+      <activation>
+        <file>
+          <exists>../assembly/zip.xml</exists>
+        </file>
+      </activation>
+      <build>       <!-- apache-release from project's parent pom enables assembly plugin on all modules, so to build the -->
+        <plugins>   <!-- wikipages zip we must fall back to invoke it on each wikipage submodule. In order to reuse some  -->
+          <plugin>  <!-- build logic, we use a custom profile. Cfr with property on each jspwiki-wikipages submodule.     -->
+            <artifactId>maven-assembly-plugin</artifactId>
+            <executions>
+              <execution>
+                <id>create-wikipages-zip</id>
+                <phase>package</phase>
+                <goals><goal>single</goal></goals>
+                <configuration>
+                  <appendAssemblyId>false</appendAssemblyId>
+                  <descriptors>
+                    <descriptor>../assembly/zip.xml</descriptor>
+                  </descriptors>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+  
+  <organization>
+    <name>The Apache Software Foundation</name>
+    <url>http://www.apache.org/</url>
+  </organization>
+
+  <licenses>
+    <license>
+      <name>The Apache Software License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <mailingLists>
+    <mailingList>
+      <name>Apache JSPWiki-dev List</name>
+      <subscribe>dev-subscribe@jspwiki.apache.org</subscribe>
+      <unsubscribe>dev-unsubscribe@jspwiki.apache.org</unsubscribe>
+      <post>dev@jspwiki.apache.org</post>
+      <archive>http://mail-archives.apache.org/mod_mbox/jspwiki-dev/</archive>
+    </mailingList>
+
+    <mailingList>
+      <name>Apache JSPWiki-user List</name>
+      <subscribe>user-subscribe@jspwiki.apache.org</subscribe>
+      <unsubscribe>user-unsubscribe@jspwiki.apache.org</unsubscribe>
+      <post>user@jspwiki.apache.org</post>
+      <archive>http://mail-archives.apache.org/mod_mbox/jspwiki-user/</archive>
+    </mailingList>
+
+    <mailingList>
+      <name>Apache JSPWiki-commits List</name>
+      <subscribe>commits-subscribe@jspwiki.apache.org</subscribe>
+      <unsubscribe>commits-unsubscribe@jspwiki.apache.org</unsubscribe>
+      <archive>http://mail-archives.apache.org/mod_mbox/jspwiki-commits/</archive>
+    </mailingList>
+  </mailingLists>
+
+  <issueManagement>
+    <system>JIRA</system>
+    <url>http://issues.apache.org/jira/browse/JSPWIKI</url>
+  </issueManagement>
+
+  <ciManagement>
+    <system>Jenkins</system>
+    <url>https://builds.apache.org/job/JSPWiki</url>
+  </ciManagement>
+</project>
