<!--
	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>
	<parent>
		<groupId>org.apache.felix</groupId>
		<artifactId>felix</artifactId>
		<version>1.0.4</version>
	</parent>
	<modelVersion>4.0.0</modelVersion>
	<packaging>bundle</packaging>
	<name>Junit4Osgi-Swing-GUI</name>
	<artifactId>org.apache.felix.ipojo.junit4osgi.swing-gui</artifactId>
	<version>1.1.0-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>${pom.groupId}</groupId>
			<artifactId>org.apache.felix.ipojo.junit4osgi</artifactId>
			<version>1.1.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
		</dependency>
	</dependencies>
	<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<configuration>
				<source>1.5</source>
				<target>1.5</target>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.apache.felix</groupId>
			<artifactId>maven-bundle-plugin</artifactId>
			<version>1.4.3</version>
			<extensions>true</extensions>
			<configuration>
				<instructions>
					<Bundle-Name>Apache Felix iPOJO OSGi Junit Runner - Swing Gui</Bundle-Name>
					<Bundle-SymbolicName> ${pom.artifactId}</Bundle-SymbolicName>
					<Private-Package> org.apache.felix.ipojo.junit4osgi.command
					</Private-Package>
					<Import-Package>org.osgi.framework;version=1.3,*
					</Import-Package>
				</instructions>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.apache.felix</groupId>
			<artifactId>maven-ipojo-plugin</artifactId>
			<version>1.3.0-SNAPSHOT</version>
			<executions>
				<execution>
					<goals>
						<goal>ipojo-bundle</goal>
					</goals>
					<configuration>
						<ignoreAnnotations>true</ignoreAnnotations>
					</configuration>
				</execution>
			</executions>
		</plugin>
		<plugin>
			<groupId>org.codehaus.mojo</groupId>
			<artifactId>rat-maven-plugin</artifactId>
			<configuration>
				<excludeSubProjects>false</excludeSubProjects>
				<useEclipseDefaultExcludes>true</useEclipseDefaultExcludes>
				<useMavenDefaultExcludes>true</useMavenDefaultExcludes>
				<excludes>
					<param>doc/*</param>
					<param>maven-eclipse.xml</param>
					<param>.checkstyle</param>
					<param>.externalToolBuilders/*</param>
				</excludes>
			</configuration>
		</plugin>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-checkstyle-plugin
			</artifactId>
			<configuration>
				<configLocation>
					http://felix.apache.org/ipojo/dev/checkstyle_ipojo.xml
				</configLocation>
				<violationSeverity>error</violationSeverity>
			</configuration>
		</plugin>
	</plugins>
</build>
</project>
