<?xml version="1.0"?>
<!-- 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>
		<artifactId>turbine-parent</artifactId>
		<groupId>org.apache.turbine</groupId>
		<version>7</version>
	</parent>

	<modelVersion>4.0.0</modelVersion>
	<groupId>org.apache.fulcrum</groupId>
	<artifactId>fulcrum-testcontainer</artifactId>
	<version>1.0.9-SNAPSHOT</version>
	<name>Fulcrum Test Container</name>
	<inceptionYear>2004</inceptionYear>
	<description>A test framework for Avalon components</description>
	<url>https://turbine.apache.org/fulcrum/fulcrum-testcontainer</url>

	<scm>
		<connection>scm:svn:http://svn.apache.org/repos/asf/turbine/fulcrum/trunk/testcontainer</connection>
		<developerConnection>scm:svn:https://svn.apache.org/repos/asf/turbine/fulcrum/trunk/testcontainer</developerConnection>
		<url>http://svn.apache.org/viewvc/turbine/fulcrum/trunk/testcontainer</url>
	</scm>

	<distributionManagement>
		<site>
			<id>apache.website</id>
			<name>Fulcrum Website</name>
			<url>http://turbine.apache.org/fulcrum/fulcrum-testcontainer/</url>
		</site>
	</distributionManagement>

	<developers>
		<developer>
			<name>Siegfried Goeschl</name>
			<id>sgoeschl</id>
			<email>sgoeschl@apache.org</email>
			<organization />
			<roles>
				<role>Java Developer</role>
			</roles>
		</developer>
	</developers>

	<dependencies>
		<!-- we still need this dependency to compile -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.13.1</version>
		</dependency>
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter</artifactId>
          <version>${junit.jupiter.version}</version>
          <!--scope>test</scope -->
        </dependency>
		<!-- use Junit 4 within Junit 5 -->
		<dependency>
			<groupId>org.junit.platform</groupId>
			<artifactId>junit-platform-runner</artifactId>
			<version>${junit.platform}</version>
             <scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.junit.platform</groupId>
			<artifactId>junit-platform-launcher</artifactId>
			<version>${junit.platform}</version>
            <scope>test</scope>
		</dependency>

		<!-- Needed if testing with YAAFI -->
		<dependency>
			<groupId>org.apache.fulcrum</groupId>
			<artifactId>fulcrum-yaafi</artifactId>
			<version>1.0.8</version>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
		</dependency>
		<dependency>
			<groupId>org.mockito</groupId>
			<artifactId>mockito-core</artifactId>
			<version>3.5.13</version>
		</dependency>
		<!-- Needed if testing with ECM -->
		<dependency>
			<groupId>org.apache.excalibur.component</groupId>
			<artifactId>excalibur-component</artifactId>
			<version>2.2.1</version>
			<type>jar</type>
			<optional>true</optional>
		</dependency>
		<!-- Log4j2 may be better used by default -->
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-api</artifactId>
			<version>${turbine.log4j2.version}</version>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>${turbine.log4j2.version}</version>
			<optional>true</optional>
		</dependency>
		<!-- log4j1.2 bridge instead of log4j -->
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-1.2-api</artifactId>
			<version>${turbine.log4j2.version}</version>
			<optional>true</optional>
		</dependency>

	</dependencies>

	<build>
		<sourceDirectory>${basedir}/src/java</sourceDirectory>
		<testSourceDirectory>${basedir}/src/test</testSourceDirectory>
		<testResources>
			<testResource>
				<directory>${basedir}/src/test</directory>
				<includes>
					<include>*.xml</include>
				</includes>
			</testResource>
		</testResources>
		<plugins>
			<plugin>
				<!-- JUnit 5 requires Surefire version 2.22.0 or higher -->
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<!-- setting the default: forkCount=1/reuseForks=true -->
					<forkCount>1</forkCount>
					<!-- setting this to false (highest isolation: each test class has its 
						own jvm process) let maven test ignore all tests? -->
					<reuseForks>true</reuseForks>
				</configuration>
				<dependencies>
					<!-- need no junit-platform-surefire-provider dependency -->
				</dependencies>
			</plugin>
		</plugins>
	</build>

	<properties>
		<turbine.site.path>fulcrum/fulcrum-testcontainer</turbine.site.path>
		<turbine.scmPubCheckoutDirectory>${turbine.site.cache}/fulcrum/testcontainer</turbine.scmPubCheckoutDirectory>
		<junit.jupiter.version>5.7.0</junit.jupiter.version>
		<junit.platform>1.7.0</junit.platform>
	</properties>

</project>
