<?xml version="1.0" encoding="UTF-8"?>
<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>
		<groupId>org.eclipse</groupId>
		<artifactId>objectteams-parent-pom</artifactId>
		<version>0.8.0-SNAPSHOT</version>
	</parent>

	<packaging>jar</packaging>
        
	<groupId>org.eclipse</groupId>
	<artifactId>objectteams-compile-test</artifactId>
	<version>1.0.0-SNAPSHOT</version>
	<name>Object Teams test project</name>

	<!-- simply repeat this declaration from the parent pom, otherwise Maven duplicates the artifactId in the path -->
	<url>http://download.eclipse.org/objectteams/maven/3/sites/${project.artifactId}</url>

	<description>
		This module demonstrates how to use Maven3 for compiling and running OT/J programs.
	</description>
    
	<licenses>
		<license>
			<name>Eclipse Public License Version 1.0</name>
			<comments>
				This file is part of "Object Teams Development Tooling"-Software

				Copyright 2010 GK Software AG and others.
				All rights reserved. This program and the accompanying materials
				are made available under the terms of the Eclipse Public License v1.0
				which accompanies this distribution, and is available at
				http://www.eclipse.org/legal/epl-v10.html

				Please visit http://www.eclipse.org/objectteams for updates and contact.

				Contributors:
					Olaf Otto - Initial concept
					Stephan Herrmann - Initial API and implementation
			</comments>
		</license>
	</licenses>

	<repositories>
		<!-- needed for finding the parent-pom: -->
		<repository>
			<id>ObjectTeamsRepository</id>
			<name>Object Teams Repository</name>
			<url>http://download.eclipse.org/objectteams/maven/3/repository</url>
		</repository>
    </repositories>

    <properties>
    	<!-- Relative path of this module: -->
    	<project-repository-path>trunk/maven/testproject</project-repository-path>
    </properties>
    
    <!-- Override inherited declaration, otherwise Maven appends the artifactId to the path -->
	<scm>
	    <connection>scm:svn:svn://dev.eclipse.org/svnroot/tools/org.eclipse.objectteams/${project-repository-path}</connection>
	    <developerConnection>scm:svn:svn+ssh://dev.eclipse.org/svnroot/tools/org.eclipse.objectteams/${project-repository-path}</developerConnection>
	    <url>http://dev.eclipse.org/viewcvs/index.cgi/${project-repository-path}?root=TOOLS_OBJECTTEAMS</url>
	</scm>

	<!-- simply repeat this declaration from the parent pom, otherwise Maven duplicates the artifactId in the path -->
	<distributionManagement>
		<site>
			<id>otSiteRepo</id>
			<name>Object Teams sites repository for Maven 3</name>
			<url>scpexe://${ot.host}:${ot.maven.repository.basepath}/sites/${project.artifactId}</url>
		</site>
	</distributionManagement>

	<dependencies>
		<!-- Testing: -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.6</version>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<reporting>
		<plugins>
			<!-- See http://mojo.codehaus.org/jdepend-maven-plugin/ -->
			<plugin>
			        <groupId>org.codehaus.mojo</groupId>
			        <artifactId>jdepend-maven-plugin</artifactId>
			        <version>2.0-beta-2</version>
			</plugin>
			<!-- See http://mojo.codehaus.org/taglist-maven-plugin/ -->
			<plugin>
			        <groupId>org.codehaus.mojo</groupId>
			        <artifactId>taglist-maven-plugin</artifactId>
			</plugin>
			<!-- See http://maven.apache.org/plugins/maven-javadoc-plugin/ -->
			<!-- Disabled as it cannot parse OT sources. -->
			<!--
			        >plugin> <groupId>org.apache.maven.plugins</groupId>
			        <artifactId>maven-javadoc-plugin</artifactId> </plugin -->
		</plugins>
	</reporting>
</project>
