build-test.xml

<?xml version="1.0"?>

<project basedir="." default="test" name="portal-test" xmlns:antelope="antlib:ise.antelope.tasks" xmlns:if="ant:if" xmlns:unless="ant:unless">
	<import file="build.xml" />

	<if>
		<and>
			<isset property="test.base.dir.name" />
			<available file="${test.base.dir.name}/test.properties" />
		</and>
		<then>
			<property file="${test.base.dir.name}/test.${user.name}.properties" />
			<property file="${test.base.dir.name}/test.${env.COMPUTERNAME}.properties" />
			<property file="${test.base.dir.name}/test.${env.HOST}.properties" />
			<property file="${test.base.dir.name}/test.${env.HOSTNAME}.properties" />
			<property file="${test.base.dir.name}/test.properties" />
		</then>
	</if>

	<property file="${project.dir}/test.generated.properties" />
	<property file="${project.dir}/test.${user.name}.properties" />
	<property file="${project.dir}/test.${env.COMPUTERNAME}.properties" />
	<property file="${project.dir}/test.${env.HOST}.properties" />
	<property file="${project.dir}/test.${env.HOSTNAME}.properties" />
	<property file="${project.dir}/test.properties" />

	<propertycopy from="app.server.${app.server.type}.start.executable" name="app.server.start.executable" />
	<propertycopy from="app.server.${app.server.type}.start.executable.arg.line" name="app.server.start.executable.arg.line" />
	<propertycopy from="app.server.${app.server.type}.stop.executable" name="app.server.stop.executable" />
	<propertycopy from="app.server.${app.server.type}.stop.executable.arg.line" name="app.server.stop.executable.arg.line" />

	<propertycopy from="browser.${browser.type}.version" name="browser.version" />

	<propertycopy from="java.jdk.${java.jdk.architecture}.version" name="java.jdk.version" />

	<propertycopy from="liferay.portal.${liferay.portal.branch}.bundle" name="liferay.portal.bundle" />

	<propertycopy from="operating.system.${operating.system.type}.version" name="operating.system.version" />

	<property location="${project.dir}/tools/putty/plink.exe" name="plink.executable" />
	<property location="${project.dir}/tools/putty/pscp.exe" name="pscp.executable" />

	<macrodef name="apply-portal-ext-properties">
		<sequential>
			<if>
				<and>
					<contains string="${app.server.portal.dir}" substring="liferay-portal.war" />
					<not>
						<equals arg1="${app.server.type}" arg2="websphere" />
					</not>
				</and>
				<then>
					<property name="test.build.liferay.portal.zip.file.name" value="${app.server.portal.dir}" />
				</then>
				<elseif>
					<equals arg1="${app.server.type}" arg2="glassfish" />
					<then>
						<property name="test.build.liferay.portal.zip.file.name" value="${app.server.glassfish.portal.war.name}" />
					</then>
				</elseif>
				<elseif>
					<equals arg1="${tcat.enabled}" arg2="true" />
					<then>
						<property name="test.build.liferay.portal.zip.file.name" value="${app.server.tcat.admin.dir}/tcat_init/webapps/${lp.version.dtd}/ROOT.war" />
					</then>
				</elseif>
			</if>

			<if>
				<isset property="test.build.liferay.portal.zip.file.name" />
				<then>
					<tstamp>
						<format pattern="yyyyMMddkkmmssSSS" property="tstamp.value" />
					</tstamp>

					<mkdir dir="${tstamp.value}" />

					<unzip dest="${tstamp.value}" src="${test.build.liferay.portal.zip.file.name}" />

					<copy
						file="portal-impl/src/portal-ext.properties"
						overwrite="true"
						tofile="${tstamp.value}/WEB-INF/classes/portal-ext.properties"
					/>

					<echo append="true" file="${tstamp.value}/WEB-INF/classes/portal-ext.properties">

module.framework.properties.osgi.console=11312</echo>

					<print-file file.name="${tstamp.value}/WEB-INF/classes/portal-ext.properties" />

					<delete file="${test.build.liferay.portal.zip.file.name}" />

					<zip basedir="${tstamp.value}" destfile="${test.build.liferay.portal.zip.file.name}" />

					<delete dir="${tstamp.value}" />

					<var name="tstamp.value" unset="true" />
				</then>
				<else>
					<copy
						file="portal-impl/src/portal-ext.properties"
						overwrite="true"
						tofile="${app.server.classes.portal.dir}/portal-ext.properties"
					/>

					<echo append="true" file="${app.server.classes.portal.dir}/portal-ext.properties">

module.framework.properties.osgi.console=11312</echo>

					<print-file file.name="${app.server.classes.portal.dir}/portal-ext.properties" />
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="check-config">
		<sequential>
			<if>
				<not>
					<or>
						<equals arg1="${app.server.type}" arg2="glassfish" />
						<equals arg1="${app.server.type}" arg2="jboss" />
						<equals arg1="${app.server.type}" arg2="jetty" />
						<equals arg1="${app.server.type}" arg2="jonas" />
						<equals arg1="${app.server.type}" arg2="resin" />
						<equals arg1="${app.server.type}" arg2="tcserver" />
						<equals arg1="${app.server.type}" arg2="tomcat" />
						<equals arg1="${app.server.type}" arg2="weblogic" />
						<equals arg1="${app.server.type}" arg2="websphere" />
						<equals arg1="${app.server.type}" arg2="wildfly" />
					</or>
				</not>
				<then>
					<fail>Please set "app.server.type" to one of the following:${line.separator}, glassfish, jboss, jetty, jonas, resin, tcserver, tomcat, weblogic, websphere, or wildfly.</fail>
				</then>
			</if>

			<if>
				<not>
					<or>
						<equals arg1="${browser.type}" arg2="android" />
						<equals arg1="${browser.type}" arg2="androidchrome" />
						<equals arg1="${browser.type}" arg2="chrome" />
						<equals arg1="${browser.type}" arg2="edge" />
						<equals arg1="${browser.type}" arg2="firefox" />
						<equals arg1="${browser.type}" arg2="internetexplorer" />
						<equals arg1="${browser.type}" arg2="iossafari" />
						<equals arg1="${browser.type}" arg2="safari" />
					</or>
				</not>
				<then>
					<fail>Please set "browser.type" to one of the following:${line.separator}android, androidchrome, chrome, edge, firefox, internetexplorer, iossafari, or safari.</fail>
				</then>
			</if>

			<if>
				<not>
					<or>
						<equals arg1="${database.type}" arg2="db2" />
						<equals arg1="${database.type}" arg2="hypersonic" />
						<equals arg1="${database.type}" arg2="mariadb" />
						<equals arg1="${database.type}" arg2="mysql" />
						<equals arg1="${database.type}" arg2="oracle" />
						<equals arg1="${database.type}" arg2="postgresql" />
						<equals arg1="${database.type}" arg2="sqlserver" />
						<equals arg1="${database.type}" arg2="sybase" />
					</or>
				</not>
				<then>
					<fail>Please set "database.type" to one of the following:${line.separator}db2, hypersonic, mariadb, mysql, oracle, postgresql, sqlserver, sybase.</fail>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="generate-gulp-user-config-json">
		<attribute name="portlet.name" />

		<attribute default="${app.server.type}" name="app.server.type" />
		<attribute default="${app.server.@{app.server.type}.dir}" name="app.server.dir" />
		<attribute default="user-config.json" name="file.name" />
		<attribute default="portlets/@{portlet.name}/docroot/js/tests/util" name="file.path" />
		<attribute default="${lp.plugins.dir}" name="plugins.dir" />
		<attribute default="${project.dir}" name="portal.dir" />

		<sequential>
			<echo file="@{plugins.dir}/@{file.path}/@{file.name}"><![CDATA[{
	"bundle": "@{app.server.dir}",
	"deployDir": "@{app.server.dir}/webapps/ROOT",
	"source": "@{portal.dir}"
}]]></echo>
		</sequential>
	</macrodef>

	<macrodef name="generate-jdbc-properties">
		<attribute name="properties.file" />
		<element name="post-action" optional="true" />

		<sequential>
			<get-database-property property.name="database.driver" />
			<get-database-property property.name="database.password" />
			<get-database-property property.name="database.url" />
			<get-database-property property.name="database.username" />

			<echo file="@{properties.file}"><![CDATA[liferay.home=${liferay.home}

jdbc.default.driverClassName=${database.driver}
jdbc.default.url=${database.url}
jdbc.default.username=${database.username}
jdbc.default.password=${database.password}

// HikariCP

jdbc.default.connectionTimeout=600000
jdbc.default.maximumPoolSize=20
jdbc.default.minimumIdle=0

jdbc.counter.maximumPoolSize=5
jdbc.counter.minimumIdle=0

// Tomcat

jdbc.default.initialSize=0
jdbc.default.maxActive=20
jdbc.default.maxIdle=0
jdbc.default.minIdle=0

jdbc.counter.initialSize=0
jdbc.counter.maxActive=5
jdbc.counter.maxIdle=0
jdbc.counter.minIdle=0

counter.jdbc.prefix=jdbc.counter.]]></echo>

			<if>
				<equals arg1="${database.type}" arg2="oracle" />
				<then>
					<echo append="true" file="@{properties.file}"><![CDATA[
jdbc.default.connectionProperties=oracle.jdbc.ReadTimeout=0;oracle.net.CONNECT_TIMEOUT=0

jdbc.counter.connectionProperties=oracle.jdbc.ReadTimeout=0;oracle.net.CONNECT_TIMEOUT=0]]></echo>
				</then>
			</if>

			<post-action />
		</sequential>
	</macrodef>

	<macrodef name="get-auto-deploy-dir">
		<sequential>
			<var name="auto.deploy.dir" unset="true" />

			<if>
				<isset property="test.class" />
				<then>
					<get-testcase-property property.name="plugins.deployment.type" />
				</then>
			</if>

			<if>
				<equals arg1="${plugins.deployment.type}" arg2="osgi" />
				<then>
					<var name="auto.deploy.dir" value="${liferay.home}/osgi/modules" />
				</then>
				<else>
					<var name="auto.deploy.dir" value="${liferay.home}/deploy" />
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-database-property">
		<attribute name="property.name" />

		<sequential>
			<check-config />

			<var name="property.name" unset="true" />
			<var name="@{property.name}" unset="true" />

			<property name="property.name" value="@{property.name}" />

			<beanshell>
				<![CDATA[
					String propertyName = project.getProperty("property.name");

					StringBuilder sb = new StringBuilder();

					sb.append("database.");
					sb.append(project.getProperty("database.type"));
					sb.append(".");
					sb.append(propertyName.substring(9));

					propertyValue = project.getProperty(sb.toString());

					project.setProperty(propertyName, propertyValue);
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="get-env-app-server">
		<sequential>
			<propertyregex
				input="${app.server.version}"
				override="true"
				property="app.server.major.version"
				regexp="(\d+\.\d+).*"
				replace="\1"
			/>

			<propertyregex
				defaultValue="${app.server.major.version}"
				global="true"
				input="${app.server.major.version}"
				override="true"
				property="app.server.major.version.build"
				regexp="\."
				replace=""
			/>

			<propertycopy
				from="env.option.app.server.${app.server.type}${app.server.major.version.build}"
				name="env.option.app.server"
				override="true"
			/>
		</sequential>
	</macrodef>

	<macrodef name="get-env-browser">
		<sequential>
			<propertyregex
				input="${browser.version}"
				override="true"
				property="browser.major.version"
				regexp="(\d+\.\d+).*"
				replace="\1"
			/>

			<propertyregex
				defaultValue="${browser.major.version}"
				global="true"
				input="${browser.major.version}"
				override="true"
				property="browser.major.version.build"
				regexp="\."
				replace=""
			/>

			<propertycopy
				from="env.option.browser.${browser.type}${browser.major.version.build}"
				name="env.option.browser"
				override="true"
			/>
		</sequential>
	</macrodef>

	<macrodef name="get-env-database">
		<sequential>
			<get-database-property property.name="database.version" />

			<propertyregex
				input="${database.version}"
				override="true"
				property="database.major.version"
				regexp="(\d+\.?\d+?(r2)?).*"
				replace="\1"
			/>

			<propertyregex
				defaultValue="${database.major.version}"
				global="true"
				input="${database.major.version}"
				override="true"
				property="database.major.version.build"
				regexp="\."
				replace=""
			/>

			<propertycopy
				from="env.option.database.${database.type}${database.major.version.build}"
				name="env.option.database"
				override="true"
			/>
		</sequential>
	</macrodef>

	<macrodef name="get-env-java-jdk">
		<sequential>
			<propertycopy
				from="env.option.java.jdk.${java.jdk.type}.${java.jdk.version}.${java.jdk.architecture}"
				name="env.option.java.jdk"
				override="true"
			/>
		</sequential>
	</macrodef>

	<macrodef name="get-env-liferay-portal">
		<sequential>
			<if>
				<not>
					<available file="git-commit-portal" />
				</not>
				<then>
					<record-git-commit-portal />
				</then>
			</if>

			<loadfile
				property="liferay.plugins.git.id"
				srcfile="git-commit-plugins"
			/>

			<loadfile
				property="liferay.portal.git.id"
				srcfile="git-commit-portal"
			/>

			<if>
				<or>
					<not>
						<isset property="env.SOURCE_JOB_BUILD_NUMBER" />
					</not>
					<equals arg1="${env.SOURCE_JOB_BUILD_NUMBER}" arg2="1" />
				</or>
				<then>
					<property name="liferay.previous.plugins.git.id" value="${liferay.plugins.git.id}" />
					<property name="liferay.previous.portal.git.id" value="${liferay.portal.git.id}" />
				</then>
				<else>
					<math
						datatype="int"
						operand1="${env.SOURCE_JOB_BUILD_NUMBER}"
						operand2="1"
						operation="-"
						result="previous.build.number"
					/>

					<property name="previous.commit.id.dir" value="${jenkins.shared.user.content.dir}/jobs/${env.SOURCE_JOB_NAME}/builds/${previous.build.number}" />

					<loadfile failonerror="false" property="liferay.previous.plugins.git.id" srcfile="${previous.commit.id.dir}/git-commit-plugins">
						<filterchain>
							<striplinebreaks/>
						</filterchain>
					</loadfile>

					<loadfile failonerror="false" property="liferay.previous.portal.git.id" srcfile="${previous.commit.id.dir}/git-commit-portal">
						<filterchain>
							<striplinebreaks/>
						</filterchain>
					</loadfile>
				</else>
			</if>

			<property name="liferay.compare.urls" value="https://github.com/liferay/liferay-plugins-ee/compare/${liferay.previous.plugins.git.id}...${liferay.plugins.git.id},https://github.com/liferay/liferay-portal-ee/compare/${liferay.previous.portal.git.id}...${liferay.portal.git.id}" />
		</sequential>
	</macrodef>

	<macrodef name="get-env-operating-system">
		<sequential>
			<propertyregex
				defaultValue="${operating.system.version}"
				global="true"
				input="${operating.system.version}"
				override="true"
				property="operating.system.version.build"
				regexp="\."
				replace=""
			/>

			<propertycopy
				from="env.option.operating.system.${operating.system.type}${operating.system.version.build}"
				name="env.option.operating.system"
				override="true"
			/>
		</sequential>
	</macrodef>

	<macrodef name="get-fixpack-version">
		<attribute name="patch.file.zip.url" />

		<sequential>
			<var name="fixpack.version" unset="true" />

			<if>
				<matches pattern="https?://" string="@{patch.file.zip.url}" />
				<then>
					<local name="patch.file.zip.url" />
					<local name="patch.requirements" />

					<property name="patch.file.zip.url" value="@{patch.file.zip.url}" />
					<get-patch-requirements patch.file.zip.url="@{patch.file.zip.url}" />

					<beanshell>
						<![CDATA[
							import java.util.regex.Matcher;
							import java.util.regex.Pattern;

							String patchFileZipURL = project.getProperty("patch.file.zip.url");
							String patchRequirements = project.getProperty("patch.requirements");

							Pattern pattern = Pattern.compile("https?://.*/liferay-fix-pack-de-(\\d+)-\\d{4}[^/]*.zip");

							Matcher matcher = pattern.matcher(patchFileZipURL);

							if (matcher.find()) {
								project.setProperty("fixpack.version", matcher.group(1));
							}
							else if ((patchRequirements != null) && patchRequirements.startsWith("de-")) {
								project.setProperty("fixpack.version", patchRequirements.substring(3));
							}
						]]>
					</beanshell>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-ip-address">
		<sequential>
			<if>
				<isset property="ip.address" />
				<then>
					<var name="ip.address" value="${ip.address}" />
				</then>
				<elseif>
					<os family="mac" />
					<then>
						<exec executable="/bin/bash" outputproperty="ip.address">
							<arg value="-c" />
							<arg value="ifconfig | grep 'inet ' | grep -v 127.0.0.1 | cut -d\  -f2" />
						</exec>
					</then>
				</elseif>
				<elseif>
					<os family="unix" />
					<then>
						<exec executable="/bin/bash" os="${os.unix}" outputproperty="ip.address">
							<arg value="-c" />
							<arg value="ifconfig eth0 | grep 'inet addr:' | cut -d: -f2 | awk '{ print $1}'" />
						</exec>
					</then>
				</elseif>
				<else>
					<fail message="Please set the property ${ip.address}." />
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-jstack-output">
		<attribute name="process.name" />

		<sequential>
			<var name="jstack.output" unset="true" />

			<execute>
				<![CDATA[
					jps > jps_output
				]]>
			</execute>

			<local name="jps.output" />

			<loadfile property="jps.output" srcfile="jps_output" />

			<if>
				<contains string="${jps.output}" substring="@{process.name}" />
				<then>
					<local name="bootstrap.pid" />

					<propertyregex
						input="${jps.output}"
						override="true"
						property="bootstrap.pid"
						regexp="(|[\S\s]*\n)([0-9]+) @{process.name}[\S\s]*"
						replace="\2"
					/>

					<execute>
						<![CDATA[
							jstack ${bootstrap.pid} > jstack_output
						]]>
					</execute>

					<loadfile property="jstack.output" srcfile="jstack_output" />
				</then>
			</if>

			<delete file="jps_output" />
			<delete file="jstack_output" />
		</sequential>
	</macrodef>

	<macrodef name="get-master-hostname">
		<attribute default="${env.JENKINS_URL}" name="jenkins.url" />

		<sequential>
			<var name="master.hostname" unset="true" />

			<propertyregex
				input="@{jenkins.url}"
				override="true"
				property="master.hostname"
				regexp="https://(test-[0-9]+-[0-9]+).liferay.com/"
				replace="\1"
			/>

			<if>
				<not>
					<isset property="master.hostname" />
				</not>
				<then>
					<propertyregex
						input="@{jenkins.url}"
						override="true"
						property="master.hostname"
						regexp="https://test.liferay.com/([0-9]+)/"
						replace="test-\1"
					/>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-module-base-dir-from-subrepository-name">
		<attribute name="subrepository.name" />

		<sequential>
			<var name="module.base.dir" unset="true" />

			<antelope:stringutil property="subrepository.name" string="@{subrepository.name}">
				<antelope:replace regex="(.+)-private" replacement="$1" />
			</antelope:stringutil>

			<for param="gitrepo.file">
				<fileset dir="${project.dir}/modules" erroronmissingdir="false" id="fileset.id">
					<include name="**/.gitrepo" />
				</fileset>
				<sequential>
					<local name="gitrepo.file.content" />

					<loadfile property="gitrepo.file.content" srcfile="@{gitrepo.file}" />

					<if>
						<or>
							<contains string="${gitrepo.file.content}" substring="git@github.com:liferay/${subrepository.name}.git" />
							<contains string="${gitrepo.file.content}" substring="git@github.com:liferay/${subrepository.name}-private.git" />
						</or>
						<then>
							<antelope:stringutil property="module.base.dir" string="@{gitrepo.file}">
								<antelope:replace regex="\\" replacement="/" />
							</antelope:stringutil>

							<antelope:stringutil property="module.base.dir" string="${module.base.dir}">
								<antelope:replace regex="(.+)\/\.gitrepo" replacement="$1" />
							</antelope:stringutil>
						</then>
					</if>
				</sequential>
			</for>

			<fail message="No module base directory found for '@{subrepository.name}'." unless="module.base.dir" />
		</sequential>
	</macrodef>

	<macrodef name="get-patch-requirements">
		<attribute name="patch.file.zip.url" />

		<sequential>
			<var name="patch.requirements" unset="true" />

			<local name="tstamp.value" />

			<tstamp>
				<format pattern="yyyyMMddkkmmssSSS" property="tstamp.value" />
			</tstamp>

			<mirrors-get dest="${tstamp.value}.zip" src="@{patch.file.zip.url}" />

			<mkdir dir="${tstamp.value}-dir" />

			<unzip dest="${tstamp.value}-dir" src="${tstamp.value}.zip" />

			<xmlproperty file="${tstamp.value}-dir/fixpack_documentation.xml" />

			<antelope:stringutil property="patch.requirements" string="${patch.requirements}">
				<antelope:replace regex="!" replacement="" />
				<antelope:replace regex="&gt;=" replacement="-" />
				<antelope:replace regex="=" replacement="-" />
			</antelope:stringutil>

			<delete dir="${tstamp.value}-dir" />
			<delete file="${tstamp.value}.zip" />
		</sequential>
	</macrodef>

	<macrodef name="get-poshi-class-name">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<var name="poshi.class.name" unset="true" />

			<get-test-simple-class-name />

			<beanshell>
				<![CDATA[
					String testSimpleClassName = project.getProperty("test.simple.class.name");

					String poshiClassName = testSimpleClassName.substring(0, testSimpleClassName.length() - 8);

					project.setProperty("poshi.class.name", poshiClassName);
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="get-poshi-dir-name">
		<sequential>
			<var name="poshi.dir.name" unset="true" />

			<if>
				<isset property="test.class" />
				<then>
					<get-poshi-test-name />

					<antelope:stringutil property="poshi.dir.name" string="${poshi.test.name}">
						<antelope:replace regex="," replacement="_" />
						<antelope:replace regex="#" replacement="_" />
					</antelope:stringutil>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-poshi-method-name">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<var name="poshi.method.name" unset="true" />

			<get-test-method-name />

			<beanshell>
				<![CDATA[
					String testMethodName = project.getProperty("test.method.name");

					String poshiClassName = testMethodName.substring(4);

					project.setProperty("poshi.method.name", poshiClassName);
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="get-poshi-test-name">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<var name="poshi.test.name" unset="true" />

			<if>
				<contains string="${test.class}" substring="#" />
				<then>
					<get-poshi-class-name />
					<get-poshi-method-name />

					<var name="poshi.test.name" value="${poshi.class.name}#${poshi.method.name}" />
				</then>
				<else>
					<get-poshi-class-name />

					<var name="poshi.test.name" value="${poshi.class.name}" />
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-test-class">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<if>
				<and>
					<matches pattern="[0-9]+_[0-9]+" string="${test.class}" />
					<not>
						<isset property="RUN_TEST_CASE_METHOD_GROUP_${test.class}" />
					</not>
				</and>
				<then>
					<loadproperties srcFile="${project.dir}/test.case.method.names.properties">
						<filterchain>
							<linecontains>
								<contains value="RUN_TEST_CASE_METHOD_GROUP_${test.class}" />
							</linecontains>
						</filterchain>
					</loadproperties>
				</then>
			</if>

			<propertycopy from="RUN_TEST_CASE_METHOD_GROUP_${test.class}" name="test.class" override="true" />
		</sequential>
	</macrodef>

	<macrodef name="get-test-class-name">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<var name="test.class.name" unset="true" />

			<get-poshi-class-name />

			<beanshell>
				<![CDATA[
					import org.apache.tools.ant.DirectoryScanner;

					String poshiClassName = project.getProperty("poshi.class.name");

					try {
						DirectoryScanner directoryScanner = new DirectoryScanner();

						if (project.getProperty("test.base.dir.name") != null) {
							directoryScanner.setBasedir(project.getProperty("test.base.dir.name"));
						}
						else {
							directoryScanner.setBasedir(project.getBaseDir());
						}

						directoryScanner.setIncludes(new String[] {"**/test/functional/**/" + poshiClassName + ".testcase"});

						directoryScanner.scan();

						String[] fileNames = directoryScanner.getIncludedFiles();

						String fileName = fileNames[0];

						int x = fileName.indexOf("/test/functional/") + 17;

						String className = fileName.substring(x);

						className = className.replaceAll("/", ".");
						className = className.replaceAll(".testcase", "TestCase");

						project.setProperty("test.class.name", className);
					}
					catch (Exception e) {
					}
				]]>
			</beanshell>

			<fail message="${test.name}.testcase does not exist." unless="test.class.name" />
		</sequential>
	</macrodef>

	<macrodef name="get-test-method-name">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<var name="test.method.name" unset="true" />

			<beanshell>
				<![CDATA[
					String testClass = project.getProperty("test.class");

					int x = testClass.indexOf("#");

					if (x != -1) {
						int y = testClass.length();

						if (testClass.contains(",")) {
							y = testClass.indexOf(",");
						}

						String testMethodName = testClass.substring(x + 1, y);

						if (!testMethodName.startsWith("test")) {
							testMethodName = "test" + testMethodName;
						}

						project.setProperty("test.method.name", testMethodName);
					}
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="get-test-simple-class-name">
		<sequential>
			<fail message="Please set the property ${test.class}." unless="test.class" />

			<var name="test.simple.class.name" unset="true" />

			<beanshell>
				<![CDATA[
					String testClass = project.getProperty("test.class");

					String testSimpleClassName = testClass;

					if (testClass.contains("#")) {
						int x = testClass.indexOf("#");

						testSimpleClassName =  testClass.substring(0, x);
					}

					if (!testSimpleClassName.endsWith("TestCase")) {
						testSimpleClassName = testSimpleClassName + "TestCase";
					}

					project.setProperty("test.simple.class.name", testSimpleClassName);
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="get-test-url">
		<sequential>
			<if>
				<matches pattern="[0-9]+_[0-9]+" string="${test.class}" />
				<then>
					<get-test-class />
				</then>
			</if>

			<get-testcase-property property.name="testcase.url" />

			<if>
				<isset property="test.url" />
				<then>
					<var name="test.url" value="${test.url}" />
				</then>
				<elseif>
					<or>
						<equals arg1="${browser.type}" arg2="android" />
						<equals arg1="${browser.type}" arg2="androidchrome" />
						<equals arg1="${browser.type}" arg2="iossafari" />
					</or>
					<then>
						<get-ip-address />

						<var name="test.url" value="http://${ip.address}:8080" />
					</then>
				</elseif>
				<elseif>
					<isset property="testcase.url" />
					<then>
						<var name="test.url" value="${testcase.url}" />
					</then>
				</elseif>
				<elseif>
					<contains string="${test.class}" substring="," />
					<then>
						<if>
							<os family="unix" />
							<then>
								<var name="test.url" value="http://${env.HOSTNAME}:8080" />
							</then>
							<elseif>
								<os family="windows" />
								<then>
									<var name="test.url" value="http://${env.COMPUTERNAME}:8080" />
								</then>
							</elseif>
						</if>
					</then>
				</elseif>
				<else>
					<var name="test.url" value="http://localhost:8080" />
				</else>
			</if>

			<get-testcase-property property.name="portal.context" />

			<if>
				<isset property="portal.context" />
				<then>
					<var name="test.url" value="${test.url}/${portal.context}" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-testcase-property">
		<attribute name="property.name" />

		<sequential>
			<var name="property.value.default" unset="true" />

			<if>
				<isset property="@{property.name}" />
				<then>
					<propertycopy from="@{property.name}" name="property.value.default" />
				</then>
			</if>

			<var name="@{property.name}" unset="true" />

			<if>
				<isset property="test.class" />
				<then>
					<property file="${project.dir}/test.generated.properties" />

					<var name="property.name" value="@{property.name}" />

					<if>
						<matches pattern="[0-9]+_[0-9]+" string="${test.class}" />
						<then>
							<get-test-class />
						</then>
					</if>

					<get-test-method-name />
					<get-test-simple-class-name />

					<beanshell>
						<![CDATA[
							String propertyName = project.getProperty("property.name");
							String propertyValueDefault = project.getProperty("property.value.default");
							String testMethodName = project.getProperty("test.method.name");
							String testSimpleClassName = project.getProperty("test.simple.class.name");

							StringBuilder sb = new StringBuilder();

							sb.append(testSimpleClassName);
							sb.append(".");
							sb.append(testMethodName);
							sb.append(".");
							sb.append(propertyName);

							String propertyValue = project.getProperty(sb.toString());

							if (propertyValue == null) {
								sb = new StringBuilder();

								sb.append(testSimpleClassName);
								sb.append(".");
								sb.append("all");
								sb.append(".");
								sb.append(propertyName);

								propertyValue = project.getProperty(sb.toString());

								if (propertyValue == null) {
									propertyValue = propertyValueDefault;
								}
							}

							project.setProperty(propertyName, propertyValue);
						]]>
					</beanshell>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-case-defect">
		<sequential>
			<if>
				<isset property="test.class" />
				<then>
					<get-testcase-property property.name="known.issues" />
				</then>
			</if>

			<condition else="" property="testray.case.defect" value="${known.issues}">
				<isset property="known.issues" />
			</condition>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-components">
		<sequential>
			<if>
				<isset property="test.class" />
				<then>
					<get-testcase-property property.name="testray.component.names" />
					<get-testcase-property property.name="testray.main.component.name" />
				</then>
			</if>

			<condition property="testray.main.component.name" value="">
				<not>
					<isset property="testray.main.component.name" />
				</not>
			</condition>

			<condition property="testray.component.names" value="${testray.main.component.name}">
				<not>
					<isset property="testray.component.names" />
				</not>
			</condition>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-logs">
		<sequential>
			<get-testray-logs-dir-name />

			<property name="testray.logs.jenkins.console" value="${testray.logs.dir.name}/jenkins-console.txt.gz" />
			<property name="testray.logs.poshi.report" value="${testray.logs.dir.name}/index.html.gz" />
			<property name="testray.logs.poshi.summary" value="${testray.logs.dir.name}/summary.html.gz" />
		</sequential>
	</macrodef>

	<macrodef name="get-testray-logs-dir-name">
		<sequential>
			<var name="build.flow.time.stamp" unset="true" />

			<beanshell>
				<![CDATA[
					import java.text.SimpleDateFormat;

					String buildFlowTimeStamp = project.getProperty("env.BUILD_FLOW_TIME_STAMP");

					if (buildFlowTimeStamp != null && buildFlowTimeStamp.matches("\\d+-\\d+-\\d+\\[\\d+:\\d+:\\d+\\]")) {
						SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd[HH:mm:ss]");

						Date date = simpleDateFormat.parse(buildFlowTimeStamp);

						project.setProperty("build.flow.time.stamp", Long.toString(date.getTime()));
					}
					else {
						project.setProperty("build.flow.time.stamp", Long.toString(System.currentTimeMillis()));
					}

					String jenkinsURL = project.getProperty("env.JENKINS_URL");

					if (jenkinsURL != null) {
						if (jenkinsURL.matches("https:\\/\\/test-\\d+-\\d+.liferay.com\\/")) {
							int x = jenkinsURL.indexOf("test");
							int y = jenkinsURL.indexOf(".");

							project.setProperty("master.hostname", jenkinsURL.substring(x, y));
						}
						else if (jenkinsURL.matches("https:\\/\\/test.liferay.com\\/\\d+\\/")) {
							int x = jenkinsURL.indexOf("com/") + 4;
							int y = jenkinsURL.length() - 1;

							project.setProperty("master.hostname", "test-" + jenkinsURL.substring(x, y));
						}
					}
				]]>
			</beanshell>

			<if>
				<isset property="test.class" />
				<then>
					<var name="batch.dir.name" value="functional-${app.server.type}-${database.type}" />

					<get-poshi-dir-name />

					<var name="test.dir.name" value="${poshi.dir.name}" />
				</then>
				<else>
					<var name="batch.dir.name" value="job-${app.server.type}-${database.type}" />

					<var name="test.dir.name" value="${env.JOB_NAME}" />
				</else>
			</if>

			<antelope:stringutil property="test.dir.name" string="${test.dir.name}">
				<antelope:replace regex="," replacement="_" />
				<antelope:replace regex="#" replacement="_" />
			</antelope:stringutil>

			<var name="testray.logs.dir.name" value="${master.hostname}/${build.flow.time.stamp}/${env.BUILD_FLOW_JOB_NAME}/${env.BUILD_FLOW_BUILD_NUMBER}/${batch.dir.name}/${test.dir.name}" />
		</sequential>
	</macrodef>

	<macrodef name="get-testray-project-name">
		<sequential>
			<propertyregex
				input="${testray.product.version}"
				override="true"
				property="testray.product.major.version"
				regexp="(\d+\.?\d+?).*"
				replace="\1"
			/>

			<propertyregex
				defaultValue="${testray.product.major.version}"
				global="true"
				input="${testray.product.major.version}"
				override="true"
				property="testray.product.major.version.build"
				regexp="\."
				replace=""
			/>

			<propertycopy
				from="testray.project.${testray.product.type}${testray.product.major.version.build}.name"
				name="testray.project.name"
				override="true"
			/>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-run-id">
		<sequential>
			<var name="testray.run.id" unset="true" />

			<propertyregex
				input="${app.server.version}"
				override="true"
				property="app.server.major.version"
				regexp="(\d+\.\d+).*"
				replace="\1"
			/>

			<propertyregex
				input="${browser.version}"
				override="true"
				property="browser.major.version"
				regexp="(\d+\.\d+).*"
				replace="\1"
			/>

			<get-database-property property.name="database.version" />

			<propertyregex
				input="${database.version}"
				override="true"
				property="database.major.version"
				regexp="(\d+\.?\d+?).*"
				replace="\1"
			/>

			<property name="testray.run.id" value="${app.server.type}-${app.server.major.version} ${database.type}-${database.major.version} ${browser.type}-${browser.major.version} ${operating.system.type}-${operating.system.version} ${java.jdk.type}-jdk${java.jdk.version}-${java.jdk.architecture}" />
		</sequential>
	</macrodef>

	<macrodef name="get-testray-team-name">
		<sequential>
			<beanshell>
				<![CDATA[
					import org.apache.commons.lang.WordUtils;

					String testrayMainComponentName = project.getProperty("testray.main.component.name");
					String testrayTeamNamesString = project.getProperty("testray.team.names");

					String[] testrayTeamNames = testrayTeamNamesString.split(",");

					for (String testrayTeamName : testrayTeamNames) {
						StringBuilder sb = new StringBuilder();

						sb.append("testray.team.");
						sb.append(testrayTeamName);
						sb.append(".component.names");

						String testrayTeamComponentNamesString = project.getProperty(sb.toString());

						Set testrayTeamComponentNames = new HashSet(Arrays.asList(testrayTeamComponentNamesString.split(",")));

						if (testrayTeamComponentNames.contains(testrayMainComponentName)) {
							project.setProperty("testray.team.name", WordUtils.capitalize(testrayTeamName.replace('-', ' ')));

							break;
						}
					}
				]]>
			</beanshell>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-testcase-description">
		<sequential>
			<if>
				<isset property="test.class" />
				<then>
					<get-testcase-property property.name="description" />
				</then>
			</if>

			<condition else="" property="testray.testcase.description" value="${description}">
				<isset property="description" />
			</condition>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-testcase-name">
		<sequential>
			<var name="testray.testcase.name" unset="true" />

			<if>
				<isset property="test.class" />
				<then>
					<get-poshi-test-name />

					<property name="testray.testcase.name" value="${poshi.test.name}" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-testcase-priority">
		<sequential>
			<var name="testray.testcase.priority" unset="true" />

			<if>
				<isset property="test.class" />
				<then>
					<get-testcase-property property.name="priority" />

					<property name="testray.testcase.priority" value="${priority}" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-testcase-product-edition">
		<sequential>
			<if>
				<isset property="test.class" />
				<then>
					<get-testcase-property property.name="testray.testcase.product.edition" />
				</then>
			</if>

			<condition property="testray.testcase.product.edition" value="CE">
				<not>
					<isset property="testray.testcase.product.edition" />
				</not>
			</condition>
		</sequential>
	</macrodef>

	<macrodef name="get-testray-testcase-warnings">
		<sequential>
			<var name="testray.testcase.warnings" unset="true" />

			<if>
				<available file="poshi-warnings.xml" />
				<then>
					<loadfile property="testray.testcase.warnings" srcfile="poshi-warnings.xml" />

					<propertyregex
						global="true"
						input="${testray.testcase.warnings}"
						override="true"
						property="testray.testcase.warnings"
						regexp="(?&lt;!&lt;value&gt;\s?)&lt;!\\?\[CDATA\\?\["
						replace="&amp;lt;!&amp;#91;CDATA&amp;#91;"
					/>

					<propertyregex
						global="true"
						input="${testray.testcase.warnings}"
						override="true"
						property="testray.testcase.warnings"
						regexp="\\?]\\?]&gt;(?!\s*&lt;\/value&gt;)"
						replace="&amp;#93;&amp;#93;&amp;gt;"
					/>
				</then>
			</if>

			<property name="testray.testcase.warnings" value="" />
		</sequential>
	</macrodef>

	<macrodef name="install-patch">
		<attribute name="patch.file.zip.url" />
		<attribute default="${app.server.parent.dir}/patching-tool" name="patching.tool.dir" />

		<sequential>
			<local name="patch.file.name" />

			<basename file="@{patch.file.zip.url}" property="patch.file.name" />

			<mirrors-get dest="@{patching.tool.dir}/patches/${patch.file.name}" src="@{patch.file.zip.url}" />

			<if>
				<contains string="${patch.file.name}" substring="hotfix" />
				<then>
					<install-patch-dependencies hotfix.file.zip.url="@{patch.file.zip.url}" />
				</then>
			</if>

			<delete file="@{patching.tool.dir}/default.properties" />

			<if>
				<equals arg1="${app.server.type}" arg2="weblogic" />
				<then>
					<echo file="@{patching.tool.dir}/default.properties">global.lib.path=${app.server.weblogic.lib.global.dir}
liferay.home=${liferay.home}
patching.mode=binary
war.path=${app.server.weblogic.portal.dir}/</echo>

					<execute dir="@{patching.tool.dir}" failonerror="true">
						patching-tool${file.suffix.bat} install -force
						patching-tool${file.suffix.bat} update-plugins
					</execute>
				</then>
				<else>
					<execute dir="@{patching.tool.dir}" failonerror="true">
						patching-tool${file.suffix.bat} auto-discovery
						patching-tool${file.suffix.bat} install -force
						patching-tool${file.suffix.bat} update-plugins
					</execute>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="install-patch-dependencies">
		<attribute name="hotfix.file.zip.url" />
		<attribute default="${app.server.parent.dir}/patching-tool" name="patching.tool.dir" />

		<sequential>
			<local name="hotfix.build.version" />
			<local name="hotfix.portal.version" />
			<local name="patch.requirements" />

			<get-patch-requirements patch.file.zip.url="@{hotfix.file.zip.url}" />

			<propertyregex
				input="@{hotfix.file.zip.url}"
				property="hotfix.build.version"
				regexp=".+/hotfix/liferay-hotfix-\d+-(\d)(\d)(\d\d).zip"
				replace="\1\2\3"
			/>

			<propertyregex
				input="@{hotfix.file.zip.url}"
				property="hotfix.portal.version"
				regexp=".+/hotfix/liferay-hotfix-\d+-(\d)(\d)(\d\d).zip"
				replace="\1.\2.\3"
			/>

			<mirrors-get
				dest="@{patching.tool.dir}/patches"
				src="http://files.liferay.com/private/ee/fix-packs/${hotfix.portal.version}/de/liferay-fix-pack-${patch.requirements}-${hotfix.build.version}.zip"
			/>
		</sequential>
	</macrodef>

	<macrodef name="poshi-execute">
		<attribute name="task" />

		<sequential>
			<update-gradle-properties />

			<if>
				<equals arg1="${test.poshi.runner.local.release}" arg2="true" />
				<then>
					<gradle-execute dir="modules/test/poshi-runner/poshi-runner" task="deploy" />
				</then>
			</if>

			<local name="java.jdk.home" />

			<if>
				<and>
					<equals arg1="${ant.java.version}" arg2="1.7" />
					<isset property="java.jdk.7.x32.home" />
				</and>
				<then>
					<property name="java.jdk.home" value="${java.jdk.7.x32.home}" />
				</then>
				<elseif>
					<isset property="java.jdk.8.x32.home" />
					<then>
						<property name="java.jdk.home" value="${java.jdk.8.x32.home}" />
					</then>
				</elseif>
			</if>

			<if>
				<and>
					<isset property="env.JENKINS_HOME" />
					<available file="${java.jdk.home}" />
				</and>
				<then>
					<gradle-execute failonerror="false" task="@{task}">
						<arg value="--build-file=portal-web/build-test.gradle" />
						<arg value="-Plocal=${test.poshi.runner.local.release}" />
						<arg value="-PposhiRunnerExtProperties=${test.ext.properties.file}" />
						<arg value="-Ptmp.maven.repository.dir=../.m2-tmp" />
						<env key="JAVA_HOME" path="${java.jdk.home}" />
					</gradle-execute>
				</then>
				<else>
					<gradle-execute failonerror="false" task="@{task}">
						<arg value="--build-file=portal-web/build-test.gradle" />
						<arg value="-Plocal=${test.poshi.runner.local.release}" />
						<arg value="-PposhiRunnerExtProperties=${test.ext.properties.file}" />
						<arg value="-Ptmp.maven.repository.dir=../.m2-tmp" />
					</gradle-execute>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-additional-bundles">
		<sequential>
			<get-testcase-property property.name="app.server.bundles.size" />

			<if>
				<isset property="app.server.bundles.size" />
				<then>
					<var name="app.server.bundle.index" value="1" />

					<antelope:repeat count="${app.server.bundles.size}">
						<set-app-server-properties
							app.server.bundle.index="${app.server.bundle.index}"
						/>

						<delete dir="${test.app.server.parent.dir}" />

						<copy todir="${test.app.server.dir}">
							<fileset dir="${app.server.dir}" />
						</copy>

						<if>
							<available file="${liferay.home}/deploy" />
							<then>
								<copy todir="${test.app.server.parent.dir}/deploy">
									<fileset dir="${liferay.home}/deploy" />
								</copy>
							</then>
						</if>

						<if>
							<available file="${liferay.home}/osgi" />
							<then>
								<copy todir="${test.app.server.parent.dir}/osgi">
									<fileset dir="${liferay.home}/osgi" />
								</copy>
							</then>
						</if>

						<chmod perm="a+x">
							<fileset dir="${test.app.server.bin.dir}">
								<include name="*.sh" />
							</fileset>
						</chmod>

						<local name="jmx.remote.port.overwrite" />

						<math
							datatype="int"
							operand1="${app.server.bundle.index}"
							operand2="${jmx.remote.port}"
							operation="+"
							result="jmx.remote.port.overwrite"
						/>

						<replace
							file="${test.app.server.bin.dir}/setenv.sh"
							token="-Dcom.sun.management.jmxremote.port=${jmx.remote.port}"
							value="-Dcom.sun.management.jmxremote.port=${jmx.remote.port.overwrite}"
						/>

						<replace
							file="${test.app.server.bin.dir}/setenv.bat"
							token="-Dcom.sun.management.jmxremote.port=${jmx.remote.port}"
							value="-Dcom.sun.management.jmxremote.port=${jmx.remote.port.overwrite}"
						/>

						<if>
							<or>
								<equals arg1="${app.server.type}" arg2="jboss" />
								<equals arg1="${app.server.type}" arg2="wildfly" />
							</or>
							<then>
								<replaceregexp
									file="${test.app.server.dir}/standalone/configuration/standalone.xml"
									match="offset:0"
									replace="offset:${app.server.bundle.index}000"
								/>
							</then>
							<elseif>
								<equals arg1="${app.server.type}" arg2="tomcat" />
								<then>
									<replaceregexp
										file="${test.app.server.dir}/conf/server.xml"
										flags="g"
										match="=&quot;8(\d\d\d)&quot;"
										replace="=&quot;${test.app.server.leading.port.number}\1&quot;"
									/>
								</then>
							</elseif>
							<elseif>
								<equals arg1="${app.server.type}" arg2="weblogic" />
								<then>
									<replace file="${test.app.server.dir}/domains/liferay/config/config.xml">
										<replacetoken><![CDATA[<listen-port>8080</listen-port>]]></replacetoken>
										<replacevalue><![CDATA[<listen-port>${test.app.server.leading.port.number}080</listen-port>]]></replacevalue>
									</replace>
								</then>
							</elseif>
						</if>

						<replace
							file="${test.app.server.classes.portal.dir}/portal-ext.properties"
							token="liferay.home=${liferay.home}"
							value="liferay.home=${test.app.server.parent.dir}"
						/>

						<math
							datatype="int"
							operand1="${app.server.bundle.index}"
							operand2="11312"
							operation="+"
							result="osgi.console.port"
						/>

						<replace
							file="${test.app.server.classes.portal.dir}/portal-ext.properties"
							token="module.framework.properties.osgi.console=11312"
							value="module.framework.properties.osgi.console=${osgi.console.port}"
						/>

						<math
							datatype="int"
							operand1="${app.server.bundle.index}"
							operand2="1"
							operation="+"
							result="app.server.bundle.index"
						/>
					</antelope:repeat>

					<var name="app.server.bundle.index" unset="true" />
				</then>
			</if>

			<get-testcase-property property.name="databases.size" />

			<if>
				<isset property="databases.size" />
				<then>
					<var name="database.index" value="1" />

					<antelope:repeat count="${databases.size}">
						<set-app-server-properties
							app.server.bundle.index="${database.index}"
						/>

						<replace
							file="${test.app.server.classes.portal.dir}/portal-ext.properties"
							token="lportal"
							value="lportal${database.index}"
						/>

						<math
							datatype="int"
							operand1="${database.index}"
							operand2="1"
							operation="+"
							result="database.index"
						/>
					</antelope:repeat>

					<var name="database.index" unset="true" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-captcha-configuration" >
		<sequential>
			<echo file="${liferay.home}/osgi/configs/com.liferay.captcha.configuration.CaptchaConfiguration.config">createAccountCaptchaEnabled=&quot;false&quot;
maxChallenges=&quot;-1&quot;
sendPasswordCaptchaEnabled=&quot;false&quot;</echo>
		</sequential>
	</macrodef>

	<macrodef name="prepare-chrome-driver">
		<sequential>
			<if>
				<os family="mac" />
				<then>
					<property name="selenium.chrome.driver.zip" value="chromedriver_mac32.zip" />
				</then>
				<elseif>
					<os family="unix" />
					<then>
						<property name="selenium.chrome.driver.zip" value="chromedriver_linux64.zip" />
					</then>
				</elseif>
				<elseif>
					<os family="windows" />
					<then>
						<property name="selenium.chrome.driver.zip" value="chromedriver_win32.zip" />
					</then>
				</elseif>
				<else>
					<then>
						<fail message="Operating system is not supported." />
					</then>
				</else>
			</if>

			<mirrors-get
				dest="tools/selenium/${selenium.chrome.driver.zip}"
				src="http://chromedriver.storage.googleapis.com/${selenium.chrome.driver.version}/${selenium.chrome.driver.zip}"
			/>

			<stop-chrome-driver />

			<unzip dest="tools/selenium" src="tools/selenium/${selenium.chrome.driver.zip}" />

			<if>
				<os family="unix" />
				<then>
					<chmod file="tools/selenium/chromedriver" perm="a+x" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-custom-properties">
		<attribute name="custom.properties" />
		<sequential>
			<for delimiter="${line.separator}" list="@{custom.properties}" param="property">
				<sequential>
					<propertyregex
						global="true"
						input="@{property}"
						override="true"
						property="propertyName"
						regexp="=.*"
						replace=""
					/>

					<propertyregex
						global="true"
						input="${propertyName}"
						override="true"
						property="propertyName"
						regexp="\["
						replace="\\\\["
					/>

					<propertyregex
						global="true"
						input="${propertyName}"
						override="true"
						property="propertyName"
						regexp="\]"
						replace="\\\\]"
					/>

					<replaceregexp file="portal-impl/src/portal-ext.properties"
						flags="g"
						match="${propertyName}=.*"
						replace=""
					/>

					<echo append="true" file="portal-impl/src/portal-ext.properties">

@{property}</echo>
				</sequential>
			</for>
		</sequential>
	</macrodef>

	<macrodef name="prepare-database-jndi">
		<sequential>
			<if>
				<not>
					<and>
						<equals arg1="${app.server.type}" arg2="tomcat" />
						<equals arg1="${database.type}" arg2="mysql" />
					</and>
				</not>
				<then>
					<fail>Tests utilizing JNDI are only available for Tomcat+MySQL.</fail>
				</then>
			</if>

			<if>
				<not>
					<resourcecontains
						resource="${app.server.dir}/conf/context.xml"
						substring="jdbc/LiferayPool"
					/>
				</not>
				<then>
					<replace file="${app.server.dir}/conf/context.xml">
						<replacetoken><![CDATA[<Context>]]></replacetoken>
						<replacevalue>
							<![CDATA[
								<Context>
									<ResourceLink name="jdbc/LiferayPool" global="jdbc/LiferayPool" type="javax.sql.DataSource" />
							]]>
						</replacevalue>
					</replace>
				</then>
			</if>

			<if>
				<not>
					<resourcecontains
						resource="${app.server.dir}/conf/server.xml"
						substring="jdbc/LiferayPool"
					/>
				</not>
				<then>
					<get-database-property property.name="database.host" />
					<get-database-property property.name="database.password" />
					<get-database-property property.name="database.schema" />
					<get-database-property property.name="database.username" />

					<replace file="${app.server.dir}/conf/server.xml">
						<replacetoken><![CDATA[<GlobalNamingResources>]]></replacetoken>
						<replacevalue expandproperties="true">
							<![CDATA[
								<GlobalNamingResources>
									<Resource
										auth="Container"
										description="Global Address Database"
										driverClassName="com.mysql.jdbc.Driver"
										maxActive="40"
										maxIdle="20"
										maxWait="1000"
										name="jdbc/LiferayPool"
										password="${database.password}"
										type="javax.sql.DataSource"
										url="jdbc:mysql://${database.host}:3306/${database.schema}?useUnicode=true&amp;characterEncoding=UTF-8&amp;useFastDateParsing=false"
										username="${database.username}"
									/>
							]]>
						</replacevalue>
					</replace>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-edge-driver">
		<sequential>
			<if>
				<os family="windows" />
				<then>
					<stop-edge-driver />

					<mirrors-get
						dest="tools/selenium/MicrosoftWebDriver.exe"
						src="http://www.microsoft.com/en-us/download/webdriver/2.0/MicrosoftWebDriver.exe"
					/>
				</then>
				<else>
					<if>
						<equals arg1="${selenium.remote.driver.enabled}" arg2="false" />
						<then>
							<fail message="Operating system is not supported." />
						</then>
					</if>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-elasticsearch-configuration" >
		<sequential>
			<echo file="${liferay.home}/osgi/config/com.liferay.portal.search.elasticsearch.configuration.ElasticsearchConfiguration.config">additionalConfigurations=&quot;
    cluster.routing.allocation.disk.threshold_enabled:\ false
    cluster.service.slow_task_logging_threshold:\ 1800s
    index.indexing.slowlog.threshold.index.warn:\ 1800s
    index.search.slowlog.threshold.fetch.warn:\ 1800s
    index.search.slowlog.threshold.query.warn:\ 1800s
    monitor.jvm.gc.old.warn:\ 1800s
    monitor.jvm.gc.young.warn:\ 1800s
    threadpool.bulk.size:\ 1
    threadpool.fetch_shard_started.size:\ 1
    threadpool.fetch_shard_store.size:\ 1
    threadpool.flush.size:\ 1
    threadpool.force_merge.size:\ 1
    threadpool.generic.size:\ 1
    threadpool.get.size:\ 1
    threadpool.index.size:\ 1
    threadpool.listener.size:\ 1
    threadpool.management.size:\ 1
    threadpool.percolate.size:\ 1
    threadpool.refresh.size:\ 1
    threadpool.search.size:\ 1
    threadpool.snapshot.size:\ 1
    threadpool.suggest.size:\ 1
    threadpool.warmer.size:\ 1
    transport.local.workers:\ 1&quot;
httpEnabled=B&quot;false&quot;
logExceptionsOnly=B&quot;false&quot;</echo>
		</sequential>
	</macrodef>

	<macrodef name="prepare-ie-driver">
		<sequential>
			<if>
				<os family="windows" />
				<then>
					<property name="selenium.ie.driver.zip" value="IEDriverServer_Win32_${selenium.ie.driver.version}.0.zip" />

					<mirrors-get
						dest="tools/selenium/${selenium.ie.driver.zip}"
						src="http://selenium-release.storage.googleapis.com/${selenium.ie.driver.version}/${selenium.ie.driver.zip}"
					/>

					<stop-ie-driver />

					<unzip dest="tools/selenium" src="tools/selenium/${selenium.ie.driver.zip}" />
				</then>
				<else>
					<if>
						<equals arg1="${selenium.remote.driver.enabled}" arg2="false" />
						<then>
							<fail message="Operating system is not supported." />
						</then>
					</if>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-patching-tool" >
		<attribute default="${app.server.parent.dir}/patching-tool" name="patching.tool.dir" />

		<sequential>
			<local name="patching.tool.name" />
			<local name="patching.tool.version" />

			<mirrors-get dest="${basedir}" src="${test.fix.pack.base.url}/patching-tool/${patching.tool.latest.txt}" />

			<loadfile property="patching.tool.version" srcFile="${patching.tool.latest.txt}" />

			<property name="patching.tool.name" value="patching-tool-${patching.tool.version}.zip" />

			<mirrors-get dest="${basedir}" src="${test.fix.pack.base.url}/patching-tool/${patching.tool.name}" />

			<delete dir="@{patching.tool.dir}" />

			<unzip dest="@{patching.tool.dir}/..">
				<fileset dir="${basedir}" includes="patching-tool*" />
			</unzip>

			<chmod perm="a+x">
				<fileset dir="@{patching.tool.dir}">
					<include name="*.sh" />
				</fileset>
			</chmod>

			<delete file="${basedir}/${patching.tool.latest.txt}" />
			<delete file="${basedir}/${patching.tool.name}" />
		</sequential>
	</macrodef>

	<macrodef name="prepare-portal-legacy-properties">
		<attribute default="portal-impl/src/portal-ext.properties" name="portal.ext.properties.file.path" />
		<attribute name="portal.major.version" />
		<sequential>
			<var name="portal.legacy.file.content" unset="true" />

			<loadfile property="portal.legacy.file.content" srcFile="portal-impl/src/portal-legacy-@{portal.major.version}.properties" />

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="\$\{resource.repositories.root\}"
				replace="$${liferay.home}"
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="dl.store.cmis.*"
				replace=""
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="dl.store.jcr.fetch.delay=.*"
				replace="dl.store.jcr.fetch.delay=500"
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="dl.store.jcr.fetch.max.failures=.*"
				replace="dl.store.jcr.fetch.max.failures=5"
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="dl.store.jcr.move.version.labels=.*"
				replace="dl.store.jcr.move.version.labels=false"
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="dl.store.s3.*"
				replace=""
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="resource.repositories.root=.*"
				replace=""
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="permissions.user.check.algorithm=.*"
				replace=""
			/>

			<propertyregex
				input="${portal.legacy.file.content}"
				override="true"
				property="portal.legacy.file.content"
				regexp="permissions.view.dynamic.inheritance=.*"
				replace=""
			/>

			<echo append="true" file="@{portal.ext.properties.file.path}">

##
## From portal-legacy-@{portal.major.version}.properties
##

${portal.legacy.file.content}</echo>

			<var name="portal.legacy.file.content" unset="true" />
		</sequential>
	</macrodef>

	<macrodef name="prepare-safari-driver">
		<sequential>
			<if>
				<os family="mac" />
				<then>
					<mirrors-get
						dest="tools/selenium/SafariDriver.safariextz"
						src="http://selenium-release.storage.googleapis.com/2.45/SafariDriver.safariextz"
					/>

					<execute>
						open ${basedir.unix}/tools/selenium/SafariDriver.safariextz
					</execute>

					<echo file="tools/selenium/safaridriver.scpt">
						<![CDATA[
tell application "System Events"
	tell process "Safari"
		repeat until (exists window 1) and subrole of window 1 is "AXDialog"
			delay 1
		end repeat

		click button 1 of front window
	end tell
end tell

tell application "Safari" to quit
						]]>
					</echo>

					<if>
						<contains string="${os.version}" substring="10.11" />
						<then>
							<replace file="tools/selenium/safaridriver.scpt">
								<replacefilter>
									<replacetoken><![CDATA[repeat until (exists window 1) and subrole of window 1 is "AXDialog"]]></replacetoken>
									<replacevalue><![CDATA[repeat until exists button 1 of sheet 1 of window 1]]></replacevalue>
								</replacefilter>
								<replacefilter>
									<replacetoken><![CDATA[click button 1 of front window]]></replacetoken>
									<replacevalue><![CDATA[click button 1 of sheet 1 of window 1]]></replacevalue>
								</replacefilter>
							</replace>
						</then>
					</if>

					<execute>
						osascript ${basedir.unix}/tools/selenium/safaridriver.scpt
					</execute>

					<delete file="tools/selenium/safaridriver.scpt" />
				</then>
				<else>
					<fail message="Operating system is not supported." />
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-test-bundles">
		<attribute name="unit" />
		<sequential>
			<if>
				<matches pattern="https?://" string="${test.build.bundle.glassfish.zip.url}" />
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.type" value="glassfish" />
						<param name="test.app.server.bin.dir" value="${app.server.glassfish.bin.dir}" />
						<param name="test.build.bundle.zip.url" value="${test.build.bundle.glassfish.zip.url}" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.glassfish}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-glassfish" />
					</then>
				</elseif>
			</if>

			<if>
				<equals arg1="${test.build.bundle.jbosseap6.0}" arg2="true" />
				<then>
					<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-jboss">
						<property name="app.server.jboss.version" value="6.0.1" />
					</ant>
				</then>
			</if>

			<if>
				<and>
					<equals arg1="${test.build.bundle.jbosseap6.1}" arg2="true" />
					<matches pattern="https?://" string="${test.build.portal.war.url}" />
				</and>
				<then>
					<app-server-properties-update>
						app.server.type=jboss
						app.server.jboss.version=6.1.0
						app.server.jboss.dir=${app.server.parent.dir}/jboss-eap-6.1
						app.server.jboss.zip.name=jboss-eap-6.1.0.zip
						app.server.jboss.zip.url=http://www.jboss.org/jbossas/downloads/jboss-eap-6.1.0.zip
					</app-server-properties-update>

					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.lib.global.dir" value="${app.server.parent.dir}/jboss-eap-6.1/modules/com/liferay/portal/main" />
						<param name="app.server.portal.dir" value="${app.server.parent.dir}/jboss-eap-6.1/standalone/deployments/ROOT.war" />
						<param name="app.server.type" value="jboss" />
					</antcall>

					<app-server-properties-reset />
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.jbosseap6.1}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-jboss">
							<property name="app.server.jboss.version" value="6.1.0" />
						</ant>
					</then>
				</elseif>
			</if>

			<if>
				<equals arg1="${test.build.bundle.jbosseap6.4}" arg2="true" />
				<then>
					<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-jboss">
						<property name="app.server.jboss.version" value="6.4.0" />
					</ant>
				</then>
			</if>

			<if>
				<matches pattern="https?://" string="${test.build.bundle.jetty.zip.url}" />
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.type" value="jetty" />
						<param name="test.app.server.bin.dir" value="${app.server.jetty.bin.dir}" />
						<param name="test.build.bundle.zip.url" value="${test.build.bundle.jetty.zip.url}" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.jetty}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-jetty" />
					</then>
				</elseif>
			</if>

			<if>
				<matches pattern="https?://" string="${test.build.bundle.jonas.zip.url}" />
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.type" value="jonas" />
						<param name="test.app.server.bin.dir" value="${app.server.jonas.bin.dir}" />
						<param name="test.build.bundle.zip.url" value="${test.build.bundle.jonas.zip.url}" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.jonas}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-jonas" />
					</then>
				</elseif>
			</if>

			<if>
				<matches pattern="https?://" string="${test.build.bundle.resin.zip.url}" />
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.type" value="resin" />
						<param name="test.app.server.bin.dir" value="${app.server.resin.bin.dir}" />
						<param name="test.build.bundle.zip.url" value="${test.build.bundle.resin.zip.url}" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.resin}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-resin" />
					</then>
				</elseif>
			</if>

			<if>
				<and>
					<equals arg1="${test.build.bundle.tcserver}" arg2="true" />
					<matches pattern="https?://" string="${test.build.portal.war.url}" />
				</and>
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.lib.global.dir" value="${app.server.tcserver.lib.global.dir}" />
						<param name="app.server.portal.dir" value="${app.server.tcserver.portal.dir}" />
						<param name="app.server.type" value="tcserver" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.tcserver}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-tcserver" />
					</then>
				</elseif>
			</if>

			<if>
				<matches pattern="https?://" string="${test.build.bundle.tomcat.zip.url}" />
				<then>
					<set-tomcat-version-number liferay.portal.bundle="${liferay.portal.bundle}" />

					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.type" value="tomcat" />
						<param name="test.app.server.bin.dir" value="${app.server.tomcat.bin.dir}" />
						<param name="test.build.bundle.zip.url" value="${test.build.bundle.tomcat.zip.url}" />
					</antcall>
				</then>
				<else>
					<if>
						<equals arg1="@{unit}" arg2="true" />
						<then>
							<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-tomcat-bare" />

							<antcall target="deploy-additional-jars" />

							<ant dir="portal-kernel" inheritAll="false" target="deploy" />

							<ant dir="portal-test" inheritAll="false" target="deploy" />

							<ant dir="portal-test-integration" inheritAll="false" target="deploy" />

							<ant dir="util-java" inheritAll="false" target="deploy" />

							<ant dir="portal-impl" inheritAll="false" target="deploy" />

							<ant dir="portal-impl" inheritAll="false" target="install-portal-snapshot" />
							<ant dir="portal-kernel" inheritAll="false" target="install-portal-snapshot" />
							<ant dir="portal-test" inheritAll="false" target="install-portal-snapshot" />
							<ant dir="portal-test-integration" inheritAll="false" target="install-portal-snapshot" />
							<ant dir="util-java" inheritAll="false" target="install-portal-snapshot" />

							<gradle-execute dir="${project.dir}/modules/core" task="deploy">
								<arg value="-Dportal.build=true" />
							</gradle-execute>
						</then>
						<else>
							<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-tomcat" />
						</else>
					</if>
				</else>
			</if>

			<setup-testable-tomcat />

			<antcall inheritAll="false" target="prepare-test-build-tomcat-dependents" />

			<if>
				<and>
					<equals arg1="${test.build.bundle.weblogic}" arg2="true" />
					<matches pattern="https?://" string="${test.build.portal.war.url}" />
				</and>
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.lib.global.dir" value="${app.server.weblogic.lib.global.dir}" />
						<param name="app.server.portal.dir" value="${app.server.weblogic.portal.dir}" />
						<param name="app.server.type" value="weblogic" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.weblogic}" arg2="true" />
					<then>
						<app-server-properties-update>
							app.server.type=weblogic
						</app-server-properties-update>

						<if>
							<equals arg1="${app.server.weblogic.version.build}" arg2="1221" />
							<then>
								<ant antfile="build-dist.xml" inheritAll="false" target="unzip-weblogic-custom" />
							</then>
							<else>
								<ant antfile="build-dist.xml" inheritAll="false" target="unzip-weblogic" />
							</else>
						</if>

						<antcall inheritAll="false" target="deploy" />

						<app-server-properties-reset />
					</then>
				</elseif>
			</if>

			<if>
				<matches pattern="https?://" string="${test.build.bundle.wildfly.zip.url}" />
				<then>
					<antcall inheritAll="false" target="prepare-test-bundle">
						<param name="app.server.type" value="wildfly" />
						<param name="test.app.server.bin.dir" value="${app.server.wildfly.bin.dir}" />
						<param name="test.build.bundle.zip.url" value="${test.build.bundle.wildfly.zip.url}" />
					</antcall>
				</then>
				<elseif>
					<equals arg1="${test.build.bundle.wildfly}" arg2="true" />
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-wildfly" />
					</then>
				</elseif>
			</if>

			<antcall target="deploy-license-xml" />

			<if>
				<matches pattern="https?://" string="${test.build.plugins.war.zip.url}" />
				<then>
					<mirrors-get
						dest="plugins.war.zip"
						src="${test.build.plugins.war.zip.url}"
					/>

					<unzip dest="." src="plugins.war.zip">
						<mapper>
							<globmapper from="plugins/*" to="plugins/marketplace/*" />
						</mapper>
					</unzip>

					<delete file="plugins.war.zip" />
				</then>
			</if>

			<if>
				<matches pattern="https?://" string="${test.extra.apps.zip.urls}" />
				<then>
					<mkdir dir="extraapps" />

					<for list="${test.extra.apps.zip.urls}" param="test.extra.apps.zip.url">
						<sequential>
							<mirrors-get
								dest="extraapps"
								src="@{test.extra.apps.zip.url}"
							/>
						</sequential>
					</for>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="prepare-test-cluster-properties">
		<sequential>
			<if>
				<not>
					<equals arg1="${app.server.type}" arg2="tomcat" />
				</not>
				<then>
					<fail>The public test clustering scripts are only available for Tomcat.</fail>
				</then>
			</if>

			<replace
				file="${app.server.tomcat.dir}/conf/server.xml"
				token="&lt;Engine name=&quot;Catalina&quot; defaultHost=&quot;localhost&quot;&gt;"
				value="&lt;Engine name=&quot;Catalina&quot; defaultHost=&quot;localhost&quot; jvmRoute=&quot;0&quot;&gt;"
			/>

			<get-testcase-property property.name="app.server.bundles.size" />

			<if>
				<isset property="app.server.bundles.size" />
				<then>
					<var name="app.server.bundle.index" value="1" />

					<antelope:repeat count="${app.server.bundles.size}">
						<set-app-server-properties
							app.server.bundle.index="${app.server.bundle.index}"
						/>

						<replace
							file="${test.app.server.dir}/conf/server.xml"
							token="&lt;Engine name=&quot;Catalina&quot; defaultHost=&quot;localhost&quot;&gt;"
							value="&lt;Engine name=&quot;Catalina&quot; defaultHost=&quot;localhost&quot; jvmRoute=&quot;${test.app.server.leading.port.number}&quot;&gt;"
						/>

						<math
							datatype="int"
							operand1="${app.server.bundle.index}"
							operand2="1"
							operation="+"
							result="app.server.bundle.index"
						/>
					</antelope:repeat>

					<var name="app.server.bundle.index" unset="true" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="print-file">
		<attribute name="file.name" />

		<sequential>
			<echo></echo>
			<echo>##</echo>
			<echo>## @{file.name}</echo>
			<echo>##</echo>
			<echo></echo>

			<loadfile property="file.content" srcFile="@{file.name}" />

			<echo>${file.content}</echo>

			<var name="file.content" unset="true" />
		</sequential>
	</macrodef>

	<macrodef name="print-gc-logs">
		<attribute name="tomcat.gc.log" />
		<attribute name="tsant.gc.log" />
		<sequential>
			<if>
				<available file="/tmp/ant-gc.log" />
				<then>
					<loadfile property="ant-gc-log" srcFile="/tmp/ant-gc.log" />

					<echo>
Ant GC log:

${ant-gc-log}
					</echo>
				</then>
				<else>
					<echo>Unable to read /tmp/ant-gc.log</echo>
				</else>
			</if>

			<if if:true="@{tomcat.gc.log}">
				<available file="/tmp/tomcat-gc.log" />
				<then>
					<loadfile property="tomcat-gc-log" srcFile="/tmp/tomcat-gc.log" />

					<echo>
Tomcat GC log:

${tomcat-gc-log}
					</echo>
				</then>
				<else>
					<echo>Unable to read /tmp/tomcat-gc.log</echo>
				</else>
			</if>

			<if if:true="@{tsant.gc.log}">
				<available file="/tmp/tsant-gc.log" />
				<then>
					<loadfile property="tsant-gc-log" srcFile="/tmp/tsant-gc.log" />

					<echo>
	Tsant GC log:

	${tsant-gc-log}</echo>
				</then>
				<else>
					<echo>Unable to read /tmp/tsant-gc.log</echo>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="record-git-commit-plugins">
		<sequential>
			<beanshell>
				<![CDATA[
					File pluginsDir = null;

					String lpPluginsDirName = project.getProperty("lp.plugins.dir");

					if ((lpPluginsDirName == null) || lpPluginsDirName.equals("")) {
						File projectDir = new File(project.getProperty("project.dir"));

						String projectDirName = projectDir.getName();

						String pluginsDirName = "liferay-plugins" + projectDirName.substring("liferay-portal".length());

						pluginsDir = new File(projectDir.getParent(), pluginsDirName);
					}
					else {
						if (lpPluginsDirName.contains("${basedir.name}")) {
							lpPluginsDirName = lpPluginsDirName.substring(0, lpPluginsDirName.lastIndexOf("/"));
						}

						pluginsDir = new File(lpPluginsDirName);
					}

					project.setProperty("git.plugins.dir", pluginsDir.toString());
				]]>
			</beanshell>

			<exec dir="${git.plugins.dir}" executable="git" outputproperty="git.commit.plugins.rev.parse">
				<arg line="rev-parse HEAD" />
			</exec>

			<echo>Recording ${git.plugins.dir} with ${git.commit.plugins.rev.parse}.</echo>

			<var name="git.plugins.dir" unset="true" />

			<echo file="git-commit-plugins">${git.commit.plugins.rev.parse}</echo>

			<if>
				<isset property="env.JENKINS_HOME" />
				<then>
					<copy
						file="git-commit-plugins"
						todir="${env.JENKINS_HOME}/userContent/jobs/${env.JOB_NAME}/builds/${env.BUILD_NUMBER}"
					/>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="record-git-commit-portal">
		<sequential>
			<exec dir="${project.dir}" executable="git" outputproperty="git.commit.portal.rev.parse">
				<arg line="rev-parse HEAD" />
			</exec>

			<echo file="git-commit-portal">${git.commit.portal.rev.parse}</echo>

			<if>
				<isset property="env.JENKINS_HOME" />
				<then>
					<copy
						file="git-commit-portal"
						todir="${env.JENKINS_HOME}/userContent/jobs/${env.JOB_NAME}/builds/${env.BUILD_NUMBER}"
					/>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="record-test-class-file-names">
		<sequential>
			<beanshell>
				<![CDATA[
					import org.apache.tools.ant.DirectoryScanner;

					List getClassGroups(List classFileNames, int groupsSize) {
						List classFileNameGroups = new ArrayList(groupsSize);

						for (int i = 0; i < groupsSize; i++) {
							classFileNameGroups.add(new ArrayList());
						}

						int i = 0;

						for (String classFileName : classFileNames) {
							List classFileNameGroup = classFileNameGroups.get(i++ % groupsSize);

							classFileNameGroup.add(classFileName);
						}

						return classFileNameGroups;
					}

					List getClassFileNames() {
						DirectoryScanner directoryScanner = new DirectoryScanner();

						String testClassModulesBaseDir = project.getProperty("test.class.modules.base.dir");
						String testClassNamesExcludes = project.getProperty("test.class.names.excludes");
						String testClassNamesIncludes = project.getProperty("test.class.names.includes");

						if (testClassModulesBaseDir != null) {
							int x = testClassModulesBaseDir.indexOf("modules");

							if (x != -1) {
								testClassModulesBaseDir = testClassModulesBaseDir.substring(x);

								StringBuilder sb = new StringBuilder();

								for (String testClassNamesInclude : testClassNamesIncludes.split(",")) {
									sb.append(testClassModulesBaseDir);
									sb.append(File.separator);
									sb.append(testClassNamesInclude);
									sb.append(",");
								}

								testClassNamesIncludes = sb.toString();
							}
						}

						directoryScanner.setBasedir(project.getBaseDir());
						directoryScanner.setExcludes(testClassNamesExcludes.split(","));
						directoryScanner.setIncludes(testClassNamesIncludes.split(","));

						directoryScanner.scan();

						List classFileNames = new ArrayList();

						for (String fileName : directoryScanner.getIncludedFiles()) {
							String classFileName = fileName.substring(fileName.indexOf("com" + File.separator), fileName.length() - 4);

							classFileName = classFileName.concat("class");

							classFileNames.add(classFileName);
						}

						Collections.sort(classFileNames);

						return classFileNames;
					}

					StringBuilder sb = new StringBuilder();

					int allTestClassGroupsSize = Integer.parseInt(project.getProperty("test.class.groups.size"));

					String autoBalanceTestClassNamesString = project.getProperty("test.class.names.auto.balance");

					String[] autoBalanceTestClassNames = autoBalanceTestClassNamesString.split(",");

					List classFileNames = getClassFileNames();

					List testClassGroups = getClassGroups(classFileNames, allTestClassGroupsSize);

					for (i = 0; i < allTestClassGroupsSize; i++) {
						List testClassGroup = testClassGroups.get(i);

						sb.append("TEST_CLASS_GROUP_");
						sb.append(i);
						sb.append("=");

						for (String testClass : testClassGroup) {
							sb.append(testClass);
							sb.append(",");
						}

						for (String testClass : autoBalanceTestClassNames) {
							if (!testClassGroup.contains(testClass)) {
								sb.append(testClass);
								sb.append(",");
							}
						}

						if (!testClassGroup.isEmpty() || autoBalanceTestClassNames.length > 0) {
							sb.setLength(sb.length() - 1);
						}

						sb.append("\n\n");
					}

					sb.append("TEST_CLASS_GROUPS=");

					for (int i = 0; i < allTestClassGroupsSize; i++) {
						sb.append(i);
						sb.append(" ");
					}

					if (allTestClassGroupsSize > 0) {
						sb.setLength(sb.length() - 1);
					}

					project.setProperty("test.class.file.names.properties.content", sb.toString());
				]]>
			</beanshell>

			<echo file="test.class.file.names.properties">${test.class.file.names.properties.content}</echo>
		</sequential>
	</macrodef>

	<macrodef name="request-cmis-repository-vm">
		<attribute name="cmis.repository.type" />

		<sequential>
			<local name="cmis.repository.lease.time" />

			<property name="cmis.repository.lease.time" value="1200000" />

			<beanshell>
				<![CDATA[
					import org.json.JSONObject;

					public JSONObject toJSONObject(String url) {
						return new JSONObject(toString(url));
					}

					public String toString(String url) {
						int retryCount = 0;

						while (true) {
							try {
								System.out.println("Downloading URL " + url);

								StringBuilder sb = new StringBuilder();

								URL urlObject = new URL(url);

								HttpURLConnection httpURLConnection = (HttpURLConnection)urlObject.openConnection();

								httpURLConnection.setRequestMethod("GET");
								httpURLConnection.setRequestProperty("Content-Type", "application/json");

								InputStream inputStream = httpURLConnection.getInputStream();

								InputStreamReader inputStreamReader = new InputStreamReader(inputStream);

								BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

								String line = null;

								while ((line = bufferedReader.readLine()) != null) {
									sb.append(line);
								}

								bufferedReader.close();

								System.out.println(sb.toString());

								return sb.toString();
							}
							catch (Exception e) {
								if (retryCount >= 5) {
									throw e;
								}

								System.out.println("Retry in 5 seconds: " + e.getMessage());

								retryCount++;

								Thread.sleep(5000);
							}
						}
					}

					String cmisRepositoryLeaseTime = project.getProperty("cmis.repository.lease.time");
					String cmisRepositoryType = project.getProperty("cmis.repository.type");
					String cmisRepositoryVMHostName = "";
					int minutes = 0;

					StringBuilder sb = new StringBuilder();

					sb.append("http://it.liferay.com/osb-ici-controller-web/vm/allocation/borrow?leaseTime=");
					sb.append(cmisRepositoryLeaseTime);
					sb.append("&resourceType=qa.");
					sb.append(cmisRepositoryType);

					while (true) {
						JSONObject jsonObject = toJSONObject(sb.toString());

						if (minutes >= 30) {
							throw new Exception("No available CMIS servers");
						}

						if (!jsonObject.has("hostname")) {
							System.out.println("Waiting for next available CMIS server: " + cmisRepositoryType);

							Thread.sleep(60000);

							minutes++;

							continue;
						}

						cmisRepositoryVMHostName = jsonObject.get("hostname");

						break;
					}

					System.out.println("Borrowing " + cmisRepositoryVMHostName);

					project.setProperty("cmis.repository.vm.host.name", cmisRepositoryVMHostName);
				]]>
			</beanshell>

			<if>
				<contains string="@{cmis.repository.type}" substring="documentum" />
				<then>
					<get-testcase-property property.name="osgi.app.includes" />

					<if>
						<contains string="${osgi.app.includes}" substring="documentum" />
						<then>
							<pathconvert property="app.bnd.file">
								<fileset dir="modules" includes="private/apps/documentum/app.bnd" />
							</pathconvert>

							<loadproperties srcFile="${app.bnd.file}">
								<filterchain>
									<linecontains>
										<contains value="Liferay-Releng-App-Title" />
									</linecontains>
								</filterchain>
							</loadproperties>

							<if>
								<available file="${project.dir}/plugins/dist/${Liferay-Releng-App-Title}.lpkg" />
								<then>
									<property name="lpkg.path" value="${project.dir}/plugins/dist/${Liferay-Releng-App-Title}.lpkg" />
								</then>
								<elseif>
									<available file="${project.dir}/plugins/marketplace/${Liferay-Releng-App-Title}.lpkg" />
									<then>
										<property name="lpkg.path" value="${project.dir}/plugins/marketplace/${Liferay-Releng-App-Title}.lpkg" />
									</then>
								</elseif>
							</if>

							<if>
								<isset property="lpkg.path" />
								<then>
									<tstamp>
										<format pattern="yyyyMMddkkmmssSSS" property="tstamp.value" />
									</tstamp>

									<mkdir dir="${tstamp.value}" />

									<unzip dest="${tstamp.value}" src="${lpkg.path}">
										<patternset>
											<include name="documentum-hook-*.war" />
										</patternset>
									</unzip>

									<pathconvert property="war.path" setonempty="false">
										<path>
											<fileset dir="${tstamp.value}" includes="documentum-hook-*.war" />
										</path>
									</pathconvert>

									<unzip dest="${tstamp.value}" src="${war.path}">
										<flattenmapper />
										<patternset>
											<include name="WEB-INF/classes/dfc.properties" />
										</patternset>
									</unzip>

									<propertyfile file="${tstamp.value}/dfc.properties">
										<entry key="dfc.docbroker.host[0]" value="${cmis.repository.vm.host.name}" />
									</propertyfile>

									<war destfile="${war.path}" update="true">
										<zipfileset file="${tstamp.value}/dfc.properties" fullpath="WEB-INF/classes/dfc.properties" />
									</war>

									<delete file="${tstamp.value}/dfc.properties" />

									<zip destfile="${lpkg.path}" update="true">
										<zipfileset dir="${tstamp.value}" includes="documentum-hook-*.war" />
									</zip>

									<delete dir="${tstamp.value}" />
								</then>
								<else>
									<propertyfile file="${project.dir}/modules/private/apps/documentum/documentum-hook/docroot/WEB-INF/src/dfc.properties">
										<entry key="dfc.docbroker.host[0]" value="${cmis.repository.vm.host.name}" />
									</propertyfile>
								</else>
							</if>
						</then>
					</if>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="rsync">
		<attribute name="rsync.dest" />
		<attribute name="rsync.src" />

		<sequential>
			<get-master-hostname />

			<var name="rsync.dest" unset="true" />

			<antelope:stringutil property="rsync.dest" string="@{rsync.dest}">
				<antelope:replace regex="\(" replacement="\\(" />
				<antelope:replace regex="\)" replacement="\\)" />
			</antelope:stringutil>

			<var name="rsync.src" unset="true" />

			<antelope:stringutil property="rsync.src" string="@{rsync.src}">
				<antelope:replace regex="\(" replacement="\\(" />
				<antelope:replace regex="\)" replacement="\\)" />
			</antelope:stringutil>

			<execute>
				rsync -avz ${rsync.src} ${master.hostname}::${rsync.dest}
			</execute>
		</sequential>
	</macrodef>

	<macrodef name="set-app-server-properties">
		<attribute default="${app.server.bin.dir}" name="app.server.bin.dir" />
		<attribute default="0" name="app.server.bundle.index" />

		<sequential>
			<var name="test.app.server.bin.dir" unset="true" />
			<var name="test.app.server.classes.portal.dir" unset="true" />
			<var name="test.app.server.deploy.dir" unset="true" />
			<var name="test.app.server.dir" unset="true" />
			<var name="test.app.server.leading.port.number" unset="true" />
			<var name="test.app.server.liferay.home" unset="true" />
			<var name="test.app.server.parent.dir" unset="true" />

			<math
				datatype="int"
				operand1="@{app.server.bundle.index}"
				operand2="8"
				operation="+"
				result="test.app.server.leading.port.number"
			/>

			<if>
				<equals arg1="@{app.server.bundle.index}" arg2="0" />
				<then>
					<var name="test.app.server.bin.dir" value="@{app.server.bin.dir}" />
					<var name="test.app.server.classes.portal.dir" value="${app.server.classes.portal.dir}" />
					<var name="test.app.server.deploy.dir" value="${app.server.deploy.dir}" />
					<var name="test.app.server.dir" value="${app.server.dir}" />
					<var name="test.app.server.liferay.home" value="${liferay.home}" />
					<var name="test.app.server.parent.dir" value="${app.server.parent.dir}" />
				</then>
				<else>
					<antelope:stringutil property="test.app.server.bin.dir" string="@{app.server.bin.dir}">
						<antelope:replace regex="(${app.server.parent.dir})(.*)" replacement="$1-@{app.server.bundle.index}$2" />
					</antelope:stringutil>

					<antelope:stringutil property="test.app.server.classes.portal.dir" string="${app.server.classes.portal.dir}">
						<antelope:replace regex="(${app.server.parent.dir})(.*)" replacement="$1-@{app.server.bundle.index}$2" />
					</antelope:stringutil>

					<antelope:stringutil property="test.app.server.deploy.dir" string="${app.server.deploy.dir}">
						<antelope:replace regex="(${app.server.parent.dir})(.*)" replacement="$1-@{app.server.bundle.index}$2" />
					</antelope:stringutil>

					<antelope:stringutil property="test.app.server.dir" string="${app.server.dir}">
						<antelope:replace regex="(${app.server.parent.dir})(.*)" replacement="$1-@{app.server.bundle.index}$2" />
					</antelope:stringutil>

					<var name="test.app.server.liferay.home" value="${app.server.parent.dir}-@{app.server.bundle.index}" />

					<antelope:stringutil property="test.app.server.parent.dir" string="${app.server.parent.dir}">
						<antelope:replace regex="(${app.server.parent.dir})(.*)" replacement="$1-@{app.server.bundle.index}$2" />
					</antelope:stringutil>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="set-portal-impl-portal-test-ext-properties">
		<sequential>
			<generate-jdbc-properties properties.file="portal-impl/test/portal-test-ext.properties">
				<post-action>
					<echo file="@{properties.file}" append="true"><![CDATA[
module.framework.base.dir=${liferay.home}/osgi

sprite.root.dir=/tmp/sprite

memory.scheduler.org.quartz.threadPool.threadCount=1

persisted.scheduler.org.quartz.threadPool.threadCount=1]]></echo>
				</post-action>
			</generate-jdbc-properties>
		</sequential>
	</macrodef>

	<macrodef name="set-portal-impl-system-ext-properties">
		<sequential>
			<echo file="portal-impl/test/system-ext.properties">log.sanitizer.enabled=false</echo>
		</sequential>
	</macrodef>

	<macrodef name="set-sybase-charset-utf8">
		<sequential>
			<get-database-property property.name="database.password" />
			<get-database-property property.name="database.schema" />
			<get-database-property property.name="database.username" />

			<echo>${env.SYBASE}/${env.SYBASE_ASE}/bin/charset -P${database.password} -S${database.schema} -U${database.username} binary.srt utf8</echo>

			<exec executable="${env.SYBASE}/${env.SYBASE_ASE}/bin/charset">
				<arg value="-P${database.password}" />
				<arg value="-S${database.schema}" />
				<arg value="-U${database.username}" />
				<arg value="binary.srt" />
				<arg value="utf8" />
			</exec>

			<echo file="set-charset.sql">sp_configure 'default sortorder id', 50, 'utf8'
go
commit
go</echo>

			<print-file file.name="set-charset.sql" />

			<exec executable="${sybase.executable}">
				<arg value="-P${database.password}" />
				<arg value="-S${database.schema}" />
				<arg value="-U${database.username}" />
				<arg line="-i set-charset.sql" />
			</exec>

			<delete file="set-charset.sql" />
			<echo>service sybase restart</echo>

			<exec executable="service">
				<arg value="sybase" />
				<arg value="restart" />
			</exec>

			<echo>Sleep for 30 seconds.</echo>

			<sleep seconds="30" />

			<echo>service sybase restart</echo>

			<exec executable="service">
				<arg value="sybase" />
				<arg value="restart" />
			</exec>

			<echo>Sleep for 30 seconds.</echo>

			<sleep seconds="30" />

			<waitfor maxwait="60" maxwaitunit="second">
				<socket port="5000" server="localhost" />
			</waitfor>

			<echo file="get-charset.sql">sp_helpsort
go</echo>

			<print-file file.name="get-charset.sql" />

			<exec executable="${sybase.executable}">
				<arg value="-P${database.password}" />
				<arg value="-S${database.schema}" />
				<arg value="-U${database.username}" />
				<arg line="-i get-charset.sql" />
			</exec>

			<delete file="get-charset.sql" />
		</sequential>
	</macrodef>

	<macrodef name="set-tomcat-version-number">
		<attribute name="liferay.portal.bundle" />

		<sequential>
			<if>
				<equals arg1="@{liferay.portal.bundle}" arg2="6.0.6" />
				<then>
					<var name="app.server.tomcat.version" value="6.0.29" />
				</then>
				<elseif>
					<equals arg1="@{liferay.portal.bundle}" arg2="6.0.12" />
					<then>
						<var name="app.server.tomcat.version" value="6.0.32" />
					</then>
				</elseif>
				<elseif>
					<or>
						<equals arg1="@{liferay.portal.bundle}" arg2="6.1.2" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.1.30" />
					</or>
					<then>
						<var name="app.server.tomcat.version" value="7.0.40" />
					</then>
				</elseif>
				<elseif>
					<equals arg1="@{liferay.portal.bundle}" arg2="6.1.20" />
					<then>
						<var name="app.server.tomcat.version" value="7.0.27" />
					</then>
				</elseif>
				<elseif>
					<or>
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.0" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.1" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.2" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.3" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.1" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.2" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.3" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.4" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.5" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.6" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.7" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.8" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.9" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.10" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.11" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.12" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.13" />
					</or>
					<then>
						<var name="app.server.tomcat.version" value="7.0.42" />
					</then>
				</elseif>
				<elseif>
					<or>
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.4" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.5" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.14" />
						<equals arg1="@{liferay.portal.bundle}" arg2="6.2.10.15" />
					</or>
					<then>
						<var name="app.server.tomcat.version" value="7.0.62" />
					</then>
				</elseif>
			</if>

			<var name="app.server.tomcat.dir" value="${app.server.parent.dir}/tomcat-${app.server.tomcat.version}" />
			<var name="app.server.tomcat.bin.dir" value="${app.server.parent.dir}/tomcat-${app.server.tomcat.version}/bin" />
			<var name="app.server.tomcat.lib.global.dir" value="${app.server.parent.dir}/tomcat-${app.server.tomcat.version}/lib/ext" />
			<var name="app.server.tomcat.zip.name" value="apache-tomcat-${app.server.tomcat.version}.zip" />
			<var name="app.server.tomcat.zip.url" value="http://archive.apache.org/dist/tomcat/tomcat-8/v${app.server.tomcat.version}/bin/${app.server.tomcat.zip.name}" />

			<echo append="true" file="app.server.${user.name}.properties">
				app.server.tomcat.dir=${app.server.tomcat.dir}
				app.server.tomcat.bin.dir=${app.server.tomcat.bin.dir}
				app.server.tomcat.lib.global.dir=${app.server.tomcat.lib.global.dir}
				app.server.tomcat.version=${app.server.tomcat.version}
				app.server.tomcat.zip.name=${app.server.tomcat.zip.name}
				app.server.tomcat.zip.url=${app.server.tomcat.zip.url}
			</echo>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-jboss">
		<sequential>
			<setup-testable-jboss-jsp-configuration />
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-jboss-jsp-configuration">
		<sequential>
			<if>
				<not>
					<resourcecontains resource="${app.server.jboss.instance.dir}/configuration/standalone.xml" substring="source-vm" />
				</not>
				<then>
					<replace file="${app.server.jboss.instance.dir}/configuration/standalone.xml">
						<replacetoken><![CDATA[jsp-configuration development="true"]]></replacetoken>
						<replacevalue><![CDATA[jsp-configuration development="true" source-vm="1.8" target-vm="1.8"]]></replacevalue>
					</replace>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat">
		<sequential>
			<setup-testable-tomcat-logging />

			<setup-testable-tomcat-manager />

			<setup-testable-tomcat-osgi-modules />

			<setup-testable-tomcat-setenv />
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-aspectj-agent">
		<sequential>
			<if>
				<not>
					<resourcecontains resource="${app.server.tomcat.dir}/bin/setenv.sh" substring="${aspectj.agent}" />
				</not>
				<then>
					<echo append="true" file="${app.server.tomcat.dir}/bin/setenv.sh">
						<![CDATA[
							CATALINA_OPTS="${CATALINA_OPTS} ${aspectj.agent} -Dorg.aspectj.weaver.loadtime.configuration=${aspectj.configuration}"
						]]>
					</echo>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-jacoco-agent">
		<sequential>
			<if>
				<not>
					<available file="${app.server.tomcat.dir}/bin/jacocoagent.jar" />
				</not>
				<then>
					<copy file="${jacoco.agent.jar}" todir="${app.server.tomcat.dir}/bin" />
				</then>
			</if>

			<var name="jacoco.agent" value="-javaagent:${app.server.tomcat.dir}/bin/jacocoagent.jar${jacoco.agent.configuration}" />

			<if>
				<not>
					<resourcecontains resource="${app.server.tomcat.dir}/bin/setenv.sh" substring="${jacoco.agent}" />
				</not>
				<then>
					<echo append="true" file="${app.server.tomcat.dir}/bin/setenv.sh">
						<![CDATA[
							if [ "$1" = "jacoco" ]
							then
								JACOCO_OPTS="${jacoco.agent}"

								CATALINA_OPTS="${CATALINA_OPTS} ${JACOCO_OPTS}"

								shift
							fi
						]]>
					</echo>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-jmx">
		<sequential>
			<var name="testable.tomcat.jmx.opts" value="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.authenticate=${jmx.remote.authenticate} -Dcom.sun.management.jmxremote.port=${jmx.remote.port} -Dcom.sun.management.jmxremote.ssl=${jmx.remote.ssl}" />

			<if>
				<not>
					<resourcecontains resource="${app.server.tomcat.dir}/bin/setenv.bat" substring="${testable.tomcat.jmx.opts}" />
				</not>
				<then>
					<echo append="true" file="${app.server.tomcat.dir}/bin/setenv.bat">
						<![CDATA[
							set "JMX_OPTS=${testable.tomcat.jmx.opts}"

							set "CATALINA_OPTS=%CATALINA_OPTS% %JMX_OPTS%"
						]]>
					</echo>
				</then>
			</if>

			<if>
				<not>
					<resourcecontains resource="${app.server.tomcat.dir}/bin/setenv.sh" substring="${testable.tomcat.jmx.opts}" />
				</not>
				<then>
					<echo append="true" file="${app.server.tomcat.dir}/bin/setenv.sh">
						<![CDATA[
							JMX_OPTS="${testable.tomcat.jmx.opts}"

							CATALINA_OPTS="${CATALINA_OPTS} ${JMX_OPTS} -Dsun.zip.disableMemoryMapping=true"
						]]>
					</echo>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-jpda-address">
		<sequential>
			<if>
				<not>
					<resourcecontains resource="${app.server.tomcat.dir}/bin/setenv.sh" substring="JPDA_ADDRESS" />
				</not>
				<then>
					<echo append="true" file="${app.server.tomcat.dir}/bin/setenv.sh">
						<![CDATA[
							JPDA_ADDRESS="8000"
						]]>
					</echo>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-logging">
		<sequential>
			<if>
				<and>
					<equals arg1="@{testable.tomcat.debug.logging}" arg2="on" />
					<not>
						<resourcecontains resource="${app.server.tomcat.dir}/conf/logging.properties" substring="org.apache.catalina.level" />
					</not>
				</and>
				<then>
					<echo append="true" file="${app.server.tomcat.dir}/conf/logging.properties">
						<![CDATA[
org.apache.catalina.level=ALL

org.apache.catalina.loader.WebappClassLoader.level=INFO
org.apache.catalina.loader.WebappLoader.level=INFO
org.apache.catalina.startup.ClassLoaderFactory.level=INFO]]>
					</echo>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-manager">
		<sequential>
			<if>
				<not>
					<available file="${app.server.tomcat.dir}/webapps/manager" type="dir" />
				</not>
				<then>
					<antelope:stringutil property="tomcat.version.beginindex" string="${app.server.tomcat.dir}">
						<antelope:indexof fromindex="0" string="tomcat-" />
					</antelope:stringutil>

					<antelope:math
						datatype="int"
						operand1="${tomcat.version.beginindex}"
						operand2="7"
						operation="+"
						result="tomcat.version.beginindex"
					/>

					<antelope:stringutil property="tomcat.version" string="${app.server.tomcat.dir}">
						<antelope:substring beginindex="${tomcat.version.beginindex}" />
					</antelope:stringutil>

					<antelope:stringutil property="tomcat.major.version.endindex" string="${tomcat.version}">
						<antelope:indexof fromindex="0" string="." />
					</antelope:stringutil>

					<antelope:stringutil property="tomcat.major.version" string="${tomcat.version}">
						<antelope:substring beginindex="0" endindex="${tomcat.major.version.endindex}" />
					</antelope:stringutil>

					<mirrors-get
						dest="tomcat.zip"
						src="${app.server.tomcat.zip.url}"
					/>

					<unzip
						dest="${app.server.tomcat.dir}/webapps"
						src="tomcat.zip"
					>
						<patternset
							includes="apache-tomcat-${tomcat.version}/webapps/manager/**/*"
						/>
						<mapper>
							<globmapper from="apache-tomcat-${tomcat.version}/webapps/*" to="*" />
						</mapper>
					</unzip>

					<delete file="tomcat.zip" />
				</then>
			</if>

			<xmltask dest="${app.server.tomcat.dir}/conf/tomcat-users.xml" source="${app.server.tomcat.dir}/conf/tomcat-users.xml">
				<copy path="/tomcat-users/role[@rolename='manager-gui']/@rolename" property="tomcat.role.manager-gui.exists" />
				<copy path="/tomcat-users/role[@rolename='manager-jmx']/@rolename" property="tomcat.role.manager-jmx.exists" />
				<copy path="/tomcat-users/role[@rolename='manager-script']/@rolename" property="tomcat.role.manager-script.exists" />
				<copy path="/tomcat-users/role[@rolename='manager-status']/@rolename" property="tomcat.role.manager-status.exists" />
				<copy path="/tomcat-users/role[@rolename='tomcat']/@rolename" property="tomcat.role.tomcat.exists" />
				<copy path="/tomcat-users/user[@username='${app.server.tomcat.manager.user}']/@username" property="tomcat.user.exists" />

				<call path="/">
					<actions>
						<if>
							<not>
								<and>
									<isset property="tomcat.role.manager-gui.exists" />
									<isset property="tomcat.role.manager-script.exists" />
									<isset property="tomcat.role.manager-jmx.exists" />
									<isset property="tomcat.role.manager-status.exists" />
									<isset property="tomcat.role.tomcat.exists" />
									<isset property="tomcat.user.exists" />
								</and>
							</not>
							<then>
								<tstamp>
									<format pattern="yyyyMMddkkmmssSSS" property="tstamp.value" />
								</tstamp>

								<copy
									file="${app.server.tomcat.dir}/conf/tomcat-users.xml"
									overwrite="true"
									tofile="${app.server.tomcat.dir}/conf/tomcat-users.xml.${tstamp.value}"
								/>
							</then>
						</if>
					</actions>
				</call>

				<insert path="/tomcat-users" unless="tomcat.role.tomcat.exists"><![CDATA[
					<role rolename="tomcat" />
				]]></insert>

				<insert path="/tomcat-users" unless="tomcat.role.manager-gui.exists"><![CDATA[
					<role rolename="manager-gui" />
				]]></insert>

				<insert path="/tomcat-users" unless="tomcat.role.manager-script.exists"><![CDATA[
					<role rolename="manager-script" />
				]]></insert>

				<insert path="/tomcat-users" unless="tomcat.role.manager-jmx.exists"><![CDATA[
					<role rolename="manager-jmx" />
				]]></insert>

				<insert path="/tomcat-users" unless="tomcat.role.manager-status.exists"><![CDATA[
					<role rolename="manager-status" />
				]]></insert>

				<insert path="/tomcat-users" unless="tomcat.user.exists"><![CDATA[
					<user
						password="${app.server.tomcat.manager.password}"
						roles="tomcat,manager-gui,manager-script,manager-jmx,manager-status"
						username="${app.server.tomcat.manager.user}"
					/>
				]]></insert>
			</xmltask>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-osgi-modules">
		<sequential>
			<copy todir="${liferay.home}/osgi/modules">
				<fileset dir="${liferay.home}/osgi/test" />
			</copy>
		</sequential>
	</macrodef>

	<macrodef name="setup-testable-tomcat-setenv">
		<sequential>
			<setup-testable-tomcat-jacoco-agent />

			<setup-testable-tomcat-aspectj-agent />

			<setup-testable-tomcat-jmx />

			<setup-testable-tomcat-jpda-address />
		</sequential>
	</macrodef>

	<macrodef name="start-android-device">
		<sequential>
			<fail message="Please set the property ${mobile.android.home}." unless="mobile.android.home" />

			<echo file="${user.home}/.android/ddms.cfg">pingId=0</echo>

			<execute>
				echo no | ${mobile.android.home}/tools/android create avd -f -n deviceName -t android-19
			</execute>

			<echo append="true" file="${user.home}/.android/avd/deviceName.avd/config.ini">
				hw.keyboard=yes
			</echo>

			<exec executable="/bin/bash" os="${os.apple},${os.unix}" spawn="true">
				<arg value="-c" />
				<arg value="${mobile.android.home}/tools/emulator -avd deviceName -no-boot-anim" />
			</exec>

			<exec executable="cmd.exe" os="${os.windows}">
				<arg value="/c" />
				<arg value="${mobile.android.home}/tools/emulator -avd deviceName -no-boot-anim" />
			</exec>

			<echo file="wait_for_android_device.sh">
				<![CDATA[
					#!/bin/bash

					bootanim=""

					until [[ $bootanim =~ "stopped" ]];
					do
						bootanim=`${mobile.android.home}/platform-tools/adb shell getprop init.svc.bootanim`

						sleep 1
					done
				]]>
			</echo>

			<chmod file="wait_for_android_device.sh" perm="a+x" />

			<exec executable="${basedir}/wait_for_android_device.sh" timeout="300000" />

			<delete file="wait_for_android_device.sh" />

			<execute>
				${mobile.android.home}/platform-tools/adb push ${basedir.unix}/portal-web/test/functional/com/liferay/portalweb/dependencies/mobile/swipe_down.sh /data/local
				${mobile.android.home}/platform-tools/adb push ${basedir.unix}/portal-web/test/functional/com/liferay/portalweb/dependencies/mobile/swipe_up.sh /data/local
				${mobile.android.home}/platform-tools/adb push ${basedir.unix}/portal-web/test/functional/com/liferay/portalweb/dependencies/mobile/tap.sh /data/local

				${mobile.android.home}/platform-tools/adb -s emulator-5554 shell chmod 0777 /data/local/swipe_down.sh
				${mobile.android.home}/platform-tools/adb -s emulator-5554 shell chmod 0777 /data/local/swipe_up.sh
				${mobile.android.home}/platform-tools/adb -s emulator-5554 shell chmod 0777 /data/local/tap.sh

				${mobile.android.home}/platform-tools/adb -s emulator-5554 shell settings put system pointer_location 1
				${mobile.android.home}/platform-tools/adb -s emulator-5554 shell settings put system show_touches 1
			</execute>
		</sequential>
	</macrodef>

	<macrodef name="start-app-server">
		<attribute default="0" name="app.server.bundle.index" />
		<attribute default="true" name="delete.liferay.home" />
		<attribute default="" name="testable.portal.started.marker.file" />

		<sequential>
			<if>
				<equals arg1="${tcat.enabled}" arg2="true" />
				<then>
					<start-app-server-cmd
						app.server.bin.dir="${app.server.tcat.admin.bin.dir}"
						app.server.bundle.index="@{app.server.bundle.index}"
						delete.liferay.home="@{delete.liferay.home}"
						testable.portal.started.marker.file="@{testable.portal.started.marker.file}"
					/>

					<start-app-server-cmd
						app.server.bin.dir="${app.server.tcat.agent.bin.dir}"
						app.server.bundle.index="@{app.server.bundle.index}"
						delete.liferay.home="@{delete.liferay.home}"
						testable.portal.started.marker.file="@{testable.portal.started.marker.file}"
					/>
				</then>
				<else>
					<start-app-server-cmd
						app.server.bundle.index="@{app.server.bundle.index}"
						delete.liferay.home="@{delete.liferay.home}"
						testable.portal.started.marker.file="@{testable.portal.started.marker.file}"
					/>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="start-app-server-cmd">
		<attribute default="${app.server.bin.dir}" name="app.server.bin.dir" />
		<attribute default="0" name="app.server.bundle.index" />
		<attribute default="true" name="delete.liferay.home" />
		<attribute default="" name="testable.portal.started.marker.file" />

		<sequential>
			<set-app-server-properties
				app.server.bin.dir="@{app.server.bin.dir}"
				app.server.bundle.index="@{app.server.bundle.index}"
			/>

			<local name="portal.not.started" />

			<if>
				<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.admin.bin.dir}" />
				<then>
					<waitfor maxwait="1" maxwaitunit="second" timeoutproperty="portal.not.started">
						<socket port="${test.app.server.leading.port.number}180" server="localhost" />
					</waitfor>
				</then>
				<elseif>
					<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.agent.bin.dir}" />
					<then>
						<waitfor maxwait="1" maxwaitunit="second" timeoutproperty="portal.not.started">
							<socket port="${test.app.server.leading.port.number}080" server="localhost" />
						</waitfor>
					</then>
				</elseif>
				<else>
					<waitfor maxwait="1" maxwaitunit="second" timeoutproperty="portal.not.started">
						<socket port="${test.app.server.leading.port.number}080" server="localhost" />
					</waitfor>
				</else>
			</if>

			<if>
				<isset property="portal.not.started" />
				<then>
					<if>
						<not>
							<equals arg1="@{testable.portal.started.marker.file}" arg2="" />
						</not>
						<then>
							<echo file="@{testable.portal.started.marker.file}" message="1" />
						</then>
					</if>

					<if>
						<or>
							<equals arg1="${app.server.type}" arg2="jboss" />
							<equals arg1="${app.server.type}" arg2="wildfly" />
						</or>
						<then>
							<echo file="${test.app.server.deploy.dir}/ROOT.war.dodeploy"></echo>
						</then>
					</if>

					<get-testcase-property property.name="portal.version" />

					<if>
						<and>
							<not>
								<isset property="portal.version" />
							</not>
							<equals arg1="@{delete.liferay.home}" arg2="true" />
						</and>
						<then>
							<antcall target="delete-liferay-home">
								<param name="keep.hypersonicdb" value="true" />
							</antcall>
						</then>
					</if>

					<delete failonerror="false" includeemptydirs="true">
						<fileset dir="${test.app.server.dir}/logs" excludes="catalina.*.log" />
					</delete>

					<if>
						<equals arg1="${test.ant.launched.by.selenium}" arg2="true" />
						<then>
							<exec dir="${test.app.server.bin.dir}" executable="${app.server.start.executable}" resolveexecutable="true">
								<arg line="${app.server.start.executable.arg.line}" />
							</exec>

							<wait-for-app-server app.server.bin.dir="@{app.server.bin.dir}" app.server.bundle.index="@{app.server.bundle.index}" />
						</then>
						<else>
							<get-testcase-property property.name="ext.plugins.includes" />

							<parallel>
								<if>
									<not>
										<isset property="ext.plugins.includes" />
									</not>
									<then>
										<sequential>
											<wait-for-app-server app.server.bin.dir="@{app.server.bin.dir}" app.server.bundle.index="@{app.server.bundle.index}" />
										</sequential>
									</then>
								</if>

								<daemons>
									<exec dir="${test.app.server.bin.dir}" executable="${app.server.start.executable}" failonerror="true" resolveexecutable="true">
										<arg line="${app.server.start.executable.arg.line}" />
									</exec>
								</daemons>
							</parallel>
						</else>
					</if>
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="start-appium">
		<sequential>
			<if>
				<or>
					<equals arg1="${browser.type}" arg2="android" />
					<equals arg1="${browser.type}" arg2="androidchrome" />
				</or>
				<then>
					<fail message="Please set the property ${mobile.android.home}." unless="mobile.android.home" />

					<parallel>
						<daemons>
							<exec executable="/bin/bash" os="${os.apple},${os.unix}">
								<env key="ANDROID_HOME" value="${mobile.android.home}" />
								<env key="PATH" value="${env.PATH}:${mobile.android.home}/tools:${mobile.android.home}/platform-tools" />
								<arg value="-c" />
								<arg value="${appium.unix.cmd}" />
							</exec>

							<exec dir="${appium.win32.dir}" executable="cmd.exe" os="${os.windows}">
								<env key="ANDROID_HOME" value="${mobile.android.home}" />
								<env key="Path" value="${env.Path}:${mobile.android.home}/tools:${mobile.android.home}/platform-tools" />
								<arg value="/c" />
								<arg value="${appium.win32.cmd}" />
							</exec>
						</daemons>
					</parallel>
				</then>
				<elseif>
					<equals arg1="${browser.type}" arg2="iossafari" />
					<then>
						<parallel>
							<daemons>
								<exec executable="/bin/bash" os="${os.apple}">
									<arg value="-c" />
									<arg value="${appium.unix.cmd}" />
								</exec>
							</daemons>
						</parallel>
					</then>
				</elseif>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="start-lcs-app-server">
		<attribute default="${app.server.bin.dir}" name="app.server.bin.dir" />
		<attribute default="0" name="app.server.bundle.index" />
		<attribute default="8" name="app.server.leading.port.number" />

		<sequential>
			<parallel>
				<sequential>
					<waitfor maxwait="5" maxwaitunit="minute" timeoutproperty="app.server.waiting.timeout">
						<socket port="@{app.server.leading.port.number}080" server="localhost" />
					</waitfor>
				</sequential>
				<daemons>
					<exec dir="@{app.server.bin.dir}" executable="${app.server.start.executable}" failonerror="true" resolveexecutable="true">
						<arg line="${app.server.start.executable.arg.line}" />
					</exec>
				</daemons>
			</parallel>

			<if>
				<equals arg1="@{app.server.bundle.index}" arg2="0" />
				<then>
					<record action="stop" name="${project.dir}/log" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="start-test-smtp-server">
		<sequential>
			<mirrors-get dest="${test.smtp.server.dir}/MockMock.jar" src="${test.smtp.server.url}" />

			<parallel>
				<daemons>
					<java fork="true" jar="${test.smtp.server.dir}/MockMock.jar">
						<arg line="-p 25000" />
					</java>
				</daemons>
			</parallel>
		</sequential>
	</macrodef>

	<macrodef name="stop-android-device">
		<sequential>
			<fail message="Please set the property ${mobile.android.home}." unless="mobile.android.home" />

			<execute>
				${mobile.android.home}/platform-tools/adb emu kill
				${mobile.android.home}/tools/android delete avd -n deviceName
			</execute>
		</sequential>
	</macrodef>

	<macrodef name="stop-app-server">
		<attribute default="0" name="app.server.bundle.index" />

		<sequential>
			<if>
				<equals arg1="${tcat.enabled}" arg2="true" />
				<then>
					<stop-app-server-cmd
						app.server.bin.dir="${app.server.tcat.admin.bin.dir}"
						app.server.bundle.index="@{app.server.bundle.index}"
					/>

					<stop-app-server-cmd
						app.server.bin.dir="${app.server.tcat.agent.bin.dir}"
						app.server.bundle.index="@{app.server.bundle.index}"
					/>
				</then>
				<else>
					<stop-app-server-cmd
						app.server.bundle.index="@{app.server.bundle.index}"
					/>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="stop-app-server-cmd">
		<attribute default="${app.server.bin.dir}" name="app.server.bin.dir" />
		<attribute default="0" name="app.server.bundle.index" />

		<sequential>
			<set-app-server-properties
				app.server.bin.dir="@{app.server.bin.dir}"
				app.server.bundle.index="@{app.server.bundle.index}"
			/>

			<if>
				<and>
					<equals arg1="@{app.server.bundle.index}" arg2="0" />
					<not>
						<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.admin.bin.dir}" />
					</not>
				</and>
				<then>
					<antcall target="clean-up-logs" />

					<record action="start" name="${project.dir}/console-shut-down" />
				</then>
			</if>

			<parallel>
				<daemons>
					<exec dir="${test.app.server.bin.dir}" executable="${app.server.stop.executable}" resolveexecutable="true">
						<arg line="${app.server.stop.executable.arg.line}" />
					</exec>
				</daemons>
				<sequential>
					<if>
						<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.admin.bin.dir}" />
						<then>
							<waitfor maxwait="5" maxwaitunit="minute" timeoutproperty="app.server.stopping.timeout">
								<not>
									<http url="http://localhost:${test.app.server.leading.port.number}180/console" />
								</not>
							</waitfor>
						</then>
						<elseif>
							<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.agent.bin.dir}" />
							<then>
								<waitfor maxwait="5" maxwaitunit="minute" timeoutproperty="app.server.stopping.timeout">
									<not>
										<http url="http://localhost:${test.app.server.leading.port.number}080" />
									</not>
								</waitfor>
							</then>
						</elseif>
						<else>
							<waitfor maxwait="5" maxwaitunit="minute" timeoutproperty="app.server.stopping.timeout">
								<not>
									<http url="http://localhost:${test.app.server.leading.port.number}080/web/guest" />
								</not>
							</waitfor>
						</else>
					</if>

					<if>
						<isset property="app.server.stopping.timeout" />
						<then>
							<get-jstack-output process.name="Bootstrap" />

							<if>
								<and>
									<equals arg1="${app.server.type}" arg2="weblogic" />
									<isset property="env.HOSTNAME" />
								</and>
								<then>
									<replaceregexp
										file="${app.server.weblogic.bin.dir}/stopWebLogic.sh"
										flags="g"
										match="(t3:\/\/)[^:]*(:\d+)"
										replace="\1${env.HOSTNAME}\2"
									/>
								</then>
							</if>

							<stop-app-server app.server.bundle.index="@{app.server.bundle.index}" />

							<fail if="app.server.stopping.timeout" message="Server is still available at ${app.server.waiting.url}.${line.separator}${jstack.output}" />
						</then>
					</if>
				</sequential>
			</parallel>

			<if>
				<and>
					<equals arg1="@{app.server.bundle.index}" arg2="0" />
					<not>
						<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.admin.bin.dir}" />
					</not>
				</and>
				<then>
					<record action="stop" name="${project.dir}/console-shut-down" />
				</then>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="stop-appium">
		<sequential>
			<exec executable="/bin/bash" os="${os.apple},${os.unix}" >
				<arg value="-c" />
				<arg value="killall node" />
			</exec>

			<exec executable="/bin/bash" os="${os.unix}" >
				<arg value="-c" />
				<arg value="fuser -k 9515/tcp" />
			</exec>

			<exec executable="cmd.exe" os="${os.windows}" >
				<arg value="/c" />
				<arg value="tskill node" />
			</exec>
		</sequential>
	</macrodef>

	<macrodef name="stop-chrome-driver">
		<sequential>
			<if>
				<os family="unix" />
				<then>
					<execute failonerror="false">
						killall chromedriver
					</execute>
				</then>
				<else>
					<execute failonerror="false">
						taskkill.exe /F /IM chromedriver.exe
					</execute>
				</else>
			</if>
		</sequential>
	</macrodef>

	<macrodef name="stop-edge-driver">
		<sequential>
			<exec executable="taskkill.exe">
				<arg line="/F /IM MicrosoftWebDriver.exe" />
			</exec>
		</sequential>
	</macrodef>

	<macrodef name="stop-ie-driver">
		<sequential>
			<exec executable="taskkill.exe">
				<arg line="/F /IM IEDriverServer.exe" />
			</exec>
		</sequential>
	</macrodef>

	<macrodef name="stop-lcs-app-server">
		<attribute default="${app.server.bin.dir}" name="app.server.bin.dir" />
		<attribute default="0" name="app.server.bundle.index" />
		<attribute default="8" name="app.server.leading.port.number" />

		<sequential>
			<if>
				<equals arg1="@{app.server.bundle.index}" arg2="0" />
				<then>
					<record action="start" name="${project.dir}/log" />
				</then>
			</if>

			<exec dir="@{app.server.bin.dir}" executable="${app.server.stop.executable}" resolveexecutable="true">
				<arg line="${app.server.stop.executable.arg.line}" />
			</exec>

			<waitfor maxwait="1" maxwaitunit="minute">
				<not>
					<socket port="@{app.server.leading.port.number}080" server="localhost" />
				</not>
			</waitfor>
		</sequential>
	</macrodef>

	<macrodef name="uninstall-patches">
		<attribute name="patching.tool.dir" />

		<sequential>
			<delete file="@{patching.tool.dir}/default.properties" />

			<if>
				<equals arg1="${app.server.type}" arg2="weblogic" />
				<then>
					<echo file="@{patching.tool.dir}/default.properties">global.lib.path=${app.server.weblogic.lib.global.dir}
liferay.home=${liferay.home}
patching.mode=binary
war.path=${app.server.weblogic.portal.dir}/</echo>

					<execute dir="@{patching.tool.dir}" failonerror="true">
						patching-tool${file.suffix.bat} revert -force
						patching-tool${file.suffix.bat} update-plugins
					</execute>
				</then>
				<else>
					<execute dir="@{patching.tool.dir}" failonerror="true">
						patching-tool${file.suffix.bat} auto-discovery
						patching-tool${file.suffix.bat} revert -force
						patching-tool${file.suffix.bat} update-plugins
					</execute>
				</else>
			</if>

			<delete dir="@{patching.tool.dir}/patches" />

			<mkdir dir="@{patching.tool.dir}/patches" />
		</sequential>
	</macrodef>

	<macrodef name="wait-for-app-server">
		<attribute name="app.server.bin.dir" />
		<attribute default="0" name="app.server.bundle.index" />

		<sequential>
			<wait-for-app-server-log />

			<local name="app.server.waiting.url" />

			<if>
				<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.admin.bin.dir}" />
				<then>
					<property name="app.server.waiting.url" value="http://localhost:${test.app.server.leading.port.number}180/console" />
				</then>
				<elseif>
					<equals arg1="@{app.server.bin.dir}" arg2="${app.server.tcat.agent.bin.dir}" />
					<then>
						<property name="app.server.waiting.url" value="http://localhost:${test.app.server.leading.port.number}080" />
					</then>
				</elseif>
				<else>
					<get-testcase-property property.name="portal.context" />

					<if>
						<isset property="portal.context" />
						<then>
							<property name="app.server.waiting.url" value="http://localhost:${test.app.server.leading.port.number}080/${portal.context}/web/guest" />
						</then>
						<else>
							<property name="app.server.waiting.url" value="http://localhost:${test.app.server.leading.port.number}080/web/guest" />
						</else>
					</if>
				</else>
			</if>

			<local name="app.server.waiting.timeout" />

			<echo>Waiting for ${app.server.waiting.url} to load</echo>

			<waitfor maxwait="${timeout.app.server.wait}" maxwaitunit="second" timeoutproperty="app.server.waiting.timeout">
				<http url="${app.server.waiting.url}" />
			</waitfor>

			<if>
				<isset property="app.server.waiting.timeout" />
				<then>
					<get-jstack-output process.name="Bootstrap" />

					<stop-app-server app.server.bundle.index="@{app.server.bundle.index}" />

					<fail if="app.server.waiting.timeout" message="No server is available at ${app.server.waiting.url}${line.separator}${jstack.output}" />
				</then>
			</if>

			<echo>${app.server.waiting.url} has loaded</echo>
		</sequential>
	</macrodef>

	<macrodef name="wait-for-app-server-log">
		<sequential>
			<if>
				<and>
					<equals arg1="${app.server.type}" arg2="tomcat" />
					<isset property="test.app.server.dir" />
				</and>
				<then>
					<local name="wait.for.app.server.log.timed.out.message" />

					<beanshell>
						<![CDATA[
							import org.apache.commons.io.FileUtils;

							import org.apache.tools.ant.DirectoryScanner;

							public String getCatalinaLogFilesContent() {
								Map catalinaLogFiles = new TreeMap();

								DirectoryScanner directoryScanner = new DirectoryScanner();

								directoryScanner.setIncludes(new String[] {project.getProperty("test.app.server.dir") + "/logs/catalina.*.log"});

								directoryScanner.scan();

								for (String filePath : directoryScanner.getIncludedFiles()) {
									String osName = project.getProperty("os.name");

									osName = osName.toLowerCase();

									if (osName.contains("win")) {
										filePath = filePath.replace("/", "\\");
									}

									File file = new File(filePath);

									catalinaLogFiles.put(Long.toString(file.lastModified()), file);
								}

								StringBuilder sb = new StringBuilder();

								SortedSet keys = new TreeSet(catalinaLogFiles.keySet());

								for (String key : keys) {
									File file = catalinaLogFiles.get(key);

									sb.append(FileUtils.readFileToString(file));
								}

								return sb.toString();
							}

							System.out.println("Waiting for server startup message");

							int timeout = Integer.parseInt(project.getProperty("timeout.app.server.wait"));

							int second = 0;

							while (true) {
								try {
									String content = getCatalinaLogFilesContent();

									if (content.contains("Server startup in")) {
										break;
									}
								}
								catch (Exception e) {
									e.printStackTrace();
								}

								if (second >= timeout) {
									project.setProperty("wait.for.app.server.log.timed.out.message", "Unable to find startup message after " + (timeout / 60) + " minutes.");

									break;
								}

								second++;

								Thread.sleep(1000);
							}
						]]>
					</beanshell>

					<if>
						<isset property="wait.for.app.server.log.timed.out.message" />
						<then>
							<get-jstack-output process.name="Bootstrap" />

							<fail message="${wait.for.app.server.log.timed.out.message}${line.separator}${jstack.output}" />
						</then>
					</if>
				</then>
			</if>
		</sequential>
	</macrodef>

	<target name="build-sql-file">
		<get-testcase-property property.name="portal.version" />

		<if>
			<isset property="portal.version" />
			<then>
				<if>
					<equals arg1="${portal.version}" arg2="6.1.2" />
					<then>
						<property name="portal.version.url.path" value="6.1.2-ga3" />
					</then>
					<elseif>
						<equals arg1="${portal.version}" arg2="6.2.3" />
						<then>
							<property name="portal.version.url.path" value="6.2.3-ga4" />
						</then>
					</elseif>
					<elseif>
						<equals arg1="${portal.version}" arg2="6.2.5" />
						<then>
							<property name="portal.version.url.path" value="6.2.5-ga6" />
						</then>
					</elseif>
					<else>
						<property name="portal.version.url.path" value="${portal.version}" />
					</else>
				</if>

				<if>
					<or>
						<equals arg1="${portal.version}" arg2="6.0.6" />
						<equals arg1="${portal.version}" arg2="6.1.2" />
						<equals arg1="${portal.version}" arg2="6.2.3" />
						<equals arg1="${portal.version}" arg2="6.2.5" />
					</or>
					<then>
						<propertycopy from="sql.legacy.base.url[ce]" name="sql.legacy.base.url" />
					</then>
					<else>
						<propertycopy from="sql.legacy.base.url[ee]" name="sql.legacy.base.url" />
					</else>
				</if>

				<propertycopy from="sql.legacy.zip[${portal.version}]" name="sql.legacy.zip" />

				<delete dir="sql/legacy" failonerror="false" />

				<tstamp>
					<format pattern="yyyyMMddkkmmssSSS" property="tstamp.value" />
				</tstamp>

				<mirrors-get dest="${tstamp.value}.zip" src="${sql.legacy.base.url}/${portal.version.url.path}/${sql.legacy.zip}" />

				<unzip dest="sql/legacy/${portal.version}" src="${tstamp.value}.zip">
					<mapper from="[^/]+/(.*)" to="\1" type="regexp" />
				</unzip>

				<delete file="${tstamp.value}.zip" />
			</then>
		</if>

		<if>
			<not>
				<equals arg1="${database.type}" arg2="hypersonic" />
			</not>
			<then>
				<get-testcase-property property.name="databases.size" />

				<if>
					<and>
						<isset property="databases.size" />
						<equals arg1="${database.type}" arg2="mysql" />
					</and>
					<then>
						<var name="database.index" value="1" />

						<echo file="create.sql">drop database if exists lportal;
create database lportal character set utf8;</echo>

						<antelope:repeat count="${databases.size}">
							<echo append="true" file="create.sql">

drop database if exists lportal${database.index};
create database lportal${database.index} character set utf8;</echo>

							<math
								datatype="int"
								operand1="${database.index}"
								operand2="1"
								operation="+"
								result="database.index"
							/>
						</antelope:repeat>

						<var name="database.index" unset="true" />
					</then>
					<else>
						<if>
							<or>
								<not>
									<isset property="sql.dir" />
								</not>
								<not>
									<isset property="sql.file" />
								</not>
							</or>
							<then>
								<get-testcase-property property.name="database.bare.enabled" />

								<if>
									<equals arg1="${database.bare.enabled}" arg2="true" />
									<then>
										<var name="database.create.suffix" value="-bare" />
									</then>
								</if>

								<property name="sql.dir" value="sql\create${database.create.suffix}\" />

								<if>
									<equals arg1="${database.type}" arg2="mariadb" />
									<then>
										<property name="sql.file" value="create${database.create.suffix}-mysql.sql" />
									</then>
									<elseif>
										<equals arg1="${database.type}" arg2="sqlserver" />
										<then>
											<property name="sql.file" value="create${database.create.suffix}-sql-server.sql" />
										</then>
									</elseif>
									<else>
										<property name="sql.file" value="create${database.create.suffix}-${database.type}.sql" />
									</else>
								</if>
							</then>
						</if>

						<copy file="${sql.dir}${sql.file}" tofile="create.sql" />
					</else>
				</if>

				<get-database-property property.name="database.device.name" />

				<if>
					<equals arg1="${database.type}" arg2="db2" />
					<then>
						<replace file="create.sql">
							<replacetoken>drop database lportal;</replacetoken>
							<replacevalue></replacevalue>
						</replace>
						<replace file="create.sql">
							<replacetoken>connect to lportal;</replacetoken>
							<replacevalue>update db cfg for lportal using logprimary 2;
update db cfg for lportal using logsecond 254;
connect to lportal;</replacevalue>
						</replace>
					</then>
					<elseif>
						<equals arg1="${database.type}" arg2="oracle" />
						<then>
							<replace file="create.sql">
								<replacetoken>grant connect,resource to &amp;1;</replacetoken>
								<replacevalue>grant connect,resource to &amp;1;
	grant unlimited tablespace to &amp;1;</replacevalue>
							</replace>
						</then>
					</elseif>
					<elseif>
						<equals arg1="${database.type}" arg2="sybase" />
						<then>
							<replace file="create.sql">
								<replacefilter>
									<replacetoken>use master
exec sp_dboption 'lportal', 'allow nulls by default' , true
go

exec sp_dboption 'lportal', 'select into/bulkcopy/pllsort' , true
go

use lportal</replacetoken>
									<replacevalue><![CDATA[use lportal
go]]></replacevalue>
								</replacefilter>
							</replace>
						</then>
					</elseif>
				</if>

				<get-database-property property.name="database.schema" />

				<if>
					<not>
						<equals arg1="${database.schema}" arg2="lportal" />
					</not>
					<then>
						<replaceregexp
							file="create.sql"
							flags="g"
							match="lportal"
							replace="${database.schema}"
						/>
					</then>
				</if>
			</then>
		</if>
	</target>

	<target name="build-test-results-xml">
		<get-env-app-server />
		<get-env-browser />
		<get-env-database />
		<get-env-java-jdk />
		<get-env-liferay-portal />
		<get-env-operating-system />
		<get-poshi-dir-name />
		<get-testray-case-defect />
		<get-testray-components />
		<get-testray-logs />
		<get-testray-project-name />
		<get-testray-run-id />
		<get-testray-team-name />
		<get-testray-testcase-description />
		<get-testray-testcase-name />
		<get-testray-testcase-priority />
		<get-testray-testcase-product-edition />
		<get-testray-testcase-warnings />

		<if>
			<and>
				<isset property="env.GITHUB_BRANCH_NAME" />
				<isset property="env.GITHUB_USERNAME" />
			</and>
			<then>
				<propertyregex
					input="${testray.build.name}"
					override="true"
					property="testray.build.name"
					regexp="(-\s)\d+(\s-)"
					replace="\1${env.GITHUB_USERNAME} - ${env.GITHUB_BRANCH_NAME}\2"
				/>
			</then>
			<elseif>
				<isset property="env.TEST_BUILD_FIX_PACK_NAME" />
				<then>
					<propertyregex
						input="${testray.build.name}"
						override="true"
						property="testray.build.name"
						regexp="(-\s)\d+(\s-)"
						replace="\1${env.TEST_BUILD_FIX_PACK_NAME}\2"
					/>
				</then>
			</elseif>
		</if>

		<if>
			<available file="portal-web/test-results/${poshi.dir.name}/index.html" />
			<then>
				<property name="test.case.attachments">
					<![CDATA[
						<attachments>
							<file name="Jenkins Console" value="${testray.logs.jenkins.console}" />
							<file name="Poshi Report" value="${testray.logs.poshi.report}" />
							<file name="Poshi Summary" value="${testray.logs.poshi.summary}" />
						</attachments>
					]]>
				</property>
			</then>
			<else>
				<property name="test.case.attachments">
					<![CDATA[
						<attachments>
							<file name="Jenkins Console" value="${testray.logs.jenkins.console}" />
						</attachments>
					]]>
				</property>
			</else>
		</if>

		<property name="test.case.properties">
			<![CDATA[
				<properties>
					<property name="testray.case.defect" value="${testray.case.defect}" />
					<property name="testray.case.type.name" value="Automated Functional Test" />
					<property name="testray.component.names" value="${testray.component.names}" />
					<property name="testray.main.component.name" value="${testray.main.component.name}" />
					<property name="testray.team.name" value="${testray.team.name}" />
					<property name="testray.testcase.description" value="${testray.testcase.description}" />
					<property name="testray.testcase.name" value="${testray.testcase.name}" />
					<property name="testray.testcase.priority" value="${testray.testcase.priority}" />
					<property name="testray.testcase.product.edition" value="${testray.testcase.product.edition}" />
					<property name="testray.testcase.warnings">
						${testray.testcase.warnings}
					</property>
				</properties>
			]]>
		</property>

		<property name="test.suite.properties">
			<![CDATA[
				<environments>
					<environment type="Application Server" option="${env.option.app.server}" />
					<environment type="Browser" option="${env.option.browser}" />
					<environment type="Database" option="${env.option.database}" />
					<environment type="Java JDK" option="${env.option.java.jdk}" />
					<environment type="Operating System" option="${env.option.operating.system}" />
				</environments>
				<properties>
					<property name="app.server.type" value="${app.server.type}" />
					<property name="app.server.version" value="${app.server.version}" />
					<property name="browser.type" value="${browser.type}" />
					<property name="browser.version" value="${browser.version}" />
					<property name="database.type" value="${database.type}" />
					<property name="database.version" value="${database.version}" />
					<property name="liferay.compare.urls" value="${liferay.compare.urls}" />
					<property name="liferay.plugins.git.id" value="${liferay.plugins.git.id}" />
					<property name="liferay.portal.branch" value="${liferay.portal.branch}" />
					<property name="liferay.portal.bundle" value="${liferay.portal.bundle}" />
					<property name="liferay.portal.git.id" value="${liferay.portal.git.id}" />
					<property name="java.jdk.architecture" value="${java.jdk.architecture}" />
					<property name="java.jdk.type" value="${java.jdk.type}" />
					<property name="java.jdk.version" value="${java.jdk.version}" />
					<property name="operating.system.type" value="${operating.system.type}" />
					<property name="operating.system.version" value="${operating.system.version}" />
					<property name="test.type" value="Automated Functional Test" />
					<property name="testray.build.name" value="${testray.build.name}" />
					<property name="testray.build.time" value="${testray.build.time}" />
					<property name="testray.build.type" value="${testray.build.type}" />
					<property name="testray.product.type" value="${testray.product.type}" />
					<property name="testray.product.version" value="${testray.product.version}" />
					<property name="testray.project.name" value="${testray.project.name}" />
					<property name="testray.run.id" value="${testray.run.id}" />
				</properties>
			]]>
		</property>

		<for param="file.name">
			<path>
				<fileset dir="modules" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="portal-impl/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="portal-kernel/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="portal-web/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="util-java/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
			</path>
			<sequential>
				<var name="file.name" value="@{file.name}" />

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="\s*\&lt;/?environment[^\n^\r]*[\n\r]"
					replace=""
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="\s*\&lt;/?propert[^\n^\r]*[\n\r]"
					replace=""
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="&lt;testcase[^&lt;]*?&lt;skipped[\s\S]*?testcase&gt;"
					replace=""
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="(\s*\&lt;testcase[^/\n]*)/&gt;"
					replace="\1&gt;${line.separator}&lt;/testcase&gt;"
				/>

				<replaceregexp
					file="@{file.name}"
					match="&lt;testcase[^&gt;]*&gt;"
					replace="${test.suite.properties}\0"
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="&lt;testcase[^&gt;]*&gt;"
					replace="\0${test.case.attachments}${line.separator}${test.case.properties}"
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="(.*classname=&quot;\S+\.(\w+).*name=&quot;(\w+)[\s\S]+?)(\$\{testray\.testcase\.name\})"
					replace="\1\2#\3"
				/>

				<if>
					<isset property="group.index" />
					<then>
						<replaceregexp
							file="@{file.name}"
							flags="g"
							match="\$\{testray\.testcase\.name\}"
							replace="${testray.main.component.name}#${group.index}"
						/>
					</then>
					<else>
						<replaceregexp
							file="@{file.name}"
							flags="g"
							match="\$\{testray\.testcase\.name\}"
							replace="${testray.main.component.name}"
						/>
					</else>
				</if>

				<if>
					<contains string="@{file.name}" substring="EvaluateLog" />
					<then>
						<replaceregexp
							file="@{file.name}"
							flags="g"
							match="testray\.testcase\.name.*(?=&quot;)"
							replace="\0_EvaluateLog"
						/>
					</then>
				</if>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="\&gt;[\n\s]*\&lt;"
					replace="\&gt;${line.separator}\&lt;"
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="(&lt;/?)error"
					replace="\1failure"
				/>

				<replaceregexp
					file="@{file.name}"
					flags="g"
					match="(&lt;failure\s*)type"
					replace="\1message"
				/>

				<local name="file.name" />

				<property name="file.name" value="@{file.name}" />

				<beanshell>
					<![CDATA[
						import java.io.BufferedReader;
						import java.io.File;
						import java.io.IOException;

						import java.util.regex.Matcher;
						import java.util.regex.Pattern;

						Pattern failurePattern = Pattern.compile("<failure message=\"(?<failureMessage>[^\"]*)\"");
						Pattern testrayTestcaseNamePattern = Pattern.compile("<property name=\"testray.testcase.name\" value=\"(?<testrayTestcaseName>[^\"]*)\" ?/>");

						BufferedReader bufferedReader = null;

						Set testcaseFailures = new HashSet();
						List testcaseNames = new ArrayList();
						Map testcasePropertyLocations = new HashMap();

						try {
							File file = new File(project.getProperty("file.name"));

							bufferedReader = new BufferedReader(new FileReader(file));

							List lines = new ArrayList();

							int lineNumber = 0;

							Integer propertiesLocation = null;
							Boolean testcaseFailed = null;
							String testrayTestcaseName = null;

							for (String line = bufferedReader.readLine(); line != null; line = bufferedReader.readLine()) {
								lineNumber++;

								lines.add(line);

								if (line.contains("<testcase>")) {
									propertiesLocation = null;
									testcaseFailed = null;
									testrayTestcaseName = null;

									continue;
								}

								Matcher testrayTestcaseNameMatcher = testrayTestcaseNamePattern.matcher(line);

								if (testrayTestcaseNameMatcher.find()) {
									testrayTestcaseName = testrayTestcaseNameMatcher.group("testrayTestcaseName");

									continue;
								}

								Matcher failureMatcher = failurePattern.matcher(line);

								if (failureMatcher.find()) {
									testcaseFailed = true;

									continue;
								}

								if (line.contains("<properties>")) {
									propertiesLocation = lineNumber;

									continue;
								}

								if (line.contains("</testcase>")) {
									if ((testrayTestcaseName != null) && (propertiesLocation != null)) {
										testcaseNames.add(testrayTestcaseName);

										testcasePropertyLocations.put(propertiesLocation, testrayTestcaseName);

										if ((testcaseFailed != null) && (testcaseFailed.equals(Boolean.TRUE))) {
											testcaseFailures.add(testrayTestcaseName);
										}

										testcaseFailed = null;
										testrayTestcaseName = null;
										propertiesLocation = null;
									}
									else {
										System.out.println("WARNING: This testcase block doesn't include a testray.testcase.name property");
									}

									testcaseFailed = null;
									testrayTestcaseName = null;
								}
							}

							bufferedReader.close();

							List propertyLocations = new ArrayList(testcasePropertyLocations.keySet());

							Collections.sort(propertyLocations, Collections.reverseOrder());

							for (Integer propertyLocation : propertyLocations) {
								String testrayTestcaseName = testcasePropertyLocations.get(propertyLocation);

								if (testcaseFailures.contains(testrayTestcaseName)) {
									lines.add(propertyLocation, "<property name=\"testray.testcase.status\" value=\"failed\" />");
								}
								else {
									lines.add(propertyLocation, "<property name=\"testray.testcase.status\" value=\"passed\" />");
								}
							}

							FileWriter fileWriter = new FileWriter(file);

							BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

							for (String line : lines) {
								bufferedWriter.write(line);
								bufferedWriter.write('\n');
							}

							bufferedWriter.close();
						}
						catch (IOException e) {
							e.printStackTrace();
						}
					]]>
				</beanshell>
			</sequential>
		</for>
	</target>

	<target name="check-config">
		<check-config />
	</target>

	<target name="check-inet-address">
		<if>
			<equals arg1="${app.server.type}" arg2="jboss" />
			<then>
				<exec executable="/bin/bash" outputproperty="inet.address">
					<arg value="-c" />
					<arg value="ifconfig eth0:0 | grep 'inet ' | sed -e 's/^[[:space:]]* inet \(addr:\)\?\([0-9\.]\+\).*/\2/'" />
				</exec>

				<if>
					<equals arg1="${inet.address}" arg2="127.0.0.1" />
					<then>
						<replace file="${app.server.jboss.instance.dir}/configuration/standalone.xml">
							<replacefilter>
								<replacetoken><![CDATA[<inet-address value="${jboss.bind.address:127.0.0.1}"/>]]></replacetoken>
								<replacevalue><![CDATA[<nic name="eth0:0" />]]></replacevalue>
							</replacefilter>
							<replacefilter>
								<replacetoken><![CDATA[<inet-address value="${jboss.bind.address.management:127.0.0.1}"/>]]></replacetoken>
								<replacevalue><![CDATA[<nic name="eth0:0" />]]></replacevalue>
							</replacefilter>
						</replace>
					</then>
				</if>
			</then>
		</if>
	</target>

	<target name="clean-app-server-deploy-dir">
		<delete failonerror="false" includeemptydirs="true">
			<fileset
				dir="${app.server.deploy.dir}"
				excludes=",*.dodeploy,*.rar,*.sar/**,*.xml,.autodeploystatus/**,liferay-portal/**,liferay-portal.war/**,marketplace-portlet/**,portal-compat-hook/**,security/**,root/**,ROOT/**,ROOT.war/**,tunnel-web/**,tunnel-web.war/**"
			/>
		</delete>
	</target>

	<target name="clean-up-bundles">
		<delete file="test.${user.name}.properties" />

		<antcall target="delete-liferay-home" />

		<delete includeemptydirs="true">
			<fileset dir="${app.server.parent.dir}" excludes="*.zip" />
		</delete>
	</target>

	<target name="clean-up-db2-processes">
		<if>
			<os family="unix" />
			<then>
				<echo file="clean_up_db2_processes.sh">
					<![CDATA[
						#!/bin/bash

						db2 db2stop force

						for i in "m" "q" "s"
						do
							for j in `ipcs -$i | grep db2 | cut -c12-21`
							do
								echo "ipcrm -$i $j"

								ipcrm -$i $j
							done
						done
					]]>
				</echo>

				<chmod file="clean_up_db2_processes.sh" perm="a+x" />

				<exec executable="${basedir}/clean_up_db2_processes.sh" />

				<delete file="clean_up_db2_processes.sh" />
			</then>
		</if>
	</target>

	<target name="clean-up-java-processes">
		<if>
			<os family="unix" />
			<then>
				<echo file="clean_up_java_processes.sh">
					<![CDATA[
						#!/bin/bash

						for i in `ps -o pid,args -e | grep /opt/java/jdk | grep -v ant | grep -v grep | grep -v jenkins | cut -c1-5`
						do
							echo "Killing $i"

							kill -9 $i
						done
					]]>
				</echo>

				<chmod file="clean_up_java_processes.sh" perm="a+x" />

				<exec executable="${basedir}/clean_up_java_processes.sh" />

				<delete file="clean_up_java_processes.sh" />
			</then>
		</if>
	</target>

	<target name="clean-up-logs">
		<delete failonerror="false" file="${project.dir}/console-shut-down" />
	</target>

	<target name="clean-up-mobile-device">
		<get-testcase-property property.name="browser.type" />

		<if>
			<equals arg1="${browser.type}" arg2="android" />
			<then>
				<stop-android-device />
			</then>
		</if>
	</target>

	<target name="clean-up-selenium-driver">
		<if>
			<equals arg1="${browser.type}" arg2="chrome" />
			<then>
				<stop-chrome-driver />
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="edge" />
			<then>
				<stop-edge-driver />
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="internetexplorer" />
			<then>
				<stop-ie-driver />
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${browser.type}" arg2="android" />
				<equals arg1="${browser.type}" arg2="androidchrome" />
				<equals arg1="${browser.type}" arg2="iossafari" />
			</or>
			<then>
				<stop-appium />
			</then>
		</if>
	</target>

	<target name="clean-up-sybase-processes">
		<if>
			<os family="unix" />
			<then>
				<echo file="clean_up_sybase_processes.sh">
					<![CDATA[
						#!/bin/bash

						for i in `ps -o pid,args -e | grep /opt/sybase | grep -v grep | cut -c1-5`
						do
							echo "Killing $i"

							kill -9 $i
						done
					]]>
				</echo>

				<chmod file="clean_up_sybase_processes.sh" perm="a+x" />

				<exec executable="${basedir}/clean_up_sybase_processes.sh" />

				<delete file="clean_up_sybase_processes.sh" />
			</then>
		</if>
	</target>

	<target name="clean-up-web-xml">
		<copy file="portal-web/docroot/WEB-INF/web.xml" overwrite="true" tofile="${app.server.dir}/webapps/ROOT/WEB-INF/web.xml" />
	</target>

	<target name="clean-version-override">
		<fail message="Please set the property ${module.dir}." unless="module.dir" />

		<gradle-execute dir="${portal.dir}/modules" task="cleanVersionOverride">
			<arg value="-b" />
			<arg value="util.gradle" />
			<arg value="-PgitRepoPath=${module.dir}" />
		</gradle-execute>
	</target>

	<target name="copy-log-file">
		<for param="log.file">
			<path>
				<fileset dir="${liferay.home}/logs">
					<include name="*.log" />
				</fileset>
			</path>
			<sequential>
				<copy file="@{log.file}" overwrite="true" tofile="log" />
			</sequential>
		</for>
	</target>

	<target name="copy-optional-jars">
		<get-database-property property.name="database.version" />

		<if>
			<and>
				<equals arg1="${database.type}" arg2="db2" />
			</and>
			<then>
				<delete failonerror="false" includeemptydirs="true">
					<fileset
						dir="${app.server.lib.global.dir}"
						includes="${jdbc.db2.driver}"
					/>
				</delete>

				<for list="${jdbc.db2.driver}" param="jdbc.driver">
					<sequential>
						<mirrors-get
							dest="${todir}"
							src="${test.jdbc.drivers.url}/db2/${database.version}/@{jdbc.driver}"
						/>
					</sequential>
				</for>
			</then>
			<elseif>
				<and>
					<equals arg1="${database.type}" arg2="mariadb" />
					<not>
						<available file="${app.server.lib.global.dir}/${jdbc.mariadb.driver}" />
					</not>
				</and>
				<then>
					<copy todir="${todir}">
						<fileset
							dir="lib/development"
							includes="${jdbc.mariadb.driver}"
						/>
					</copy>
				</then>
			</elseif>
			<elseif>
				<and>
					<equals arg1="${database.type}" arg2="mysql" />
					<not>
						<available file="${app.server.lib.global.dir}/${jdbc.mysql.driver}" />
					</not>
				</and>
				<then>
					<copy todir="${todir}">
						<fileset
							dir="lib/development"
							includes="${jdbc.mysql.driver}"
						/>
					</copy>
				</then>
			</elseif>
			<elseif>
				<and>
					<equals arg1="${database.type}" arg2="oracle" />
				</and>
				<then>
					<delete failonerror="false" includeemptydirs="true">
						<fileset
							dir="${app.server.lib.global.dir}"
							includes="${jdbc.oracle.driver}"
						/>
					</delete>

					<mirrors-get
						dest="${todir}"
						src="${test.jdbc.drivers.url}/oracle/${database.version}/${jdbc.oracle.driver}"
					/>
				</then>
			</elseif>
			<elseif>
				<and>
					<equals arg1="${database.type}" arg2="postgresql" />
					<not>
						<available file="${app.server.lib.global.dir}/${jdbc.postgresql.driver}" />
					</not>
				</and>
				<then>
					<copy todir="${todir}">
						<fileset
							dir="lib/development"
							includes="${jdbc.postgresql.driver}"
						/>
					</copy>
				</then>
			</elseif>
			<elseif>
				<equals arg1="${database.type}" arg2="sqlserver" />
				<then>
					<delete failonerror="false" includeemptydirs="true">
						<fileset
							dir="${app.server.lib.global.dir}"
							includes="${jdbc.sqlserver.driver}"
						/>
					</delete>

					<mirrors-get
						dest="${todir}"
						src="${test.jdbc.drivers.url}/sqlserver/${database.version}/${jdbc.sqlserver.driver}"
					/>
				</then>
			</elseif>
			<elseif>
				<and>
					<equals arg1="${database.type}" arg2="sybase" />
				</and>
				<then>
					<delete failonerror="false" includeemptydirs="true">
						<fileset
							dir="${app.server.lib.global.dir}"
							includes="${jdbc.sybase.driver}"
						/>
					</delete>

					<mirrors-get
						dest="${todir}"
						src="${test.jdbc.drivers.url}/sybase/${database.version}/${jdbc.sybase.driver}"
					/>
				</then>
			</elseif>
		</if>

		<if>
			<or>
				<equals arg1="${app.server.type}" arg2="jboss" />
				<equals arg1="${app.server.type}" arg2="wildfly" />
			</or>
			<then>
				<propertycopy from="app.server.${app.server.type}.lib.global.dir" name="app.server.lib.global.dir" override="true" />

				<if>
					<equals arg1="${database.type}" arg2="db2" />
					<then>
						<replace file="${app.server.lib.global.dir}/module.xml">
							<replacetoken><![CDATA[<resource-root path="hsql.jar" />]]></replacetoken>
							<replacevalue>
								<![CDATA[
									<resource-root path="db2jcc4.jar" />
									<resource-root path="db2jcc_license_cu.jar" />
									<resource-root path="hsql.jar" />
								]]>
							</replacevalue>
						</replace>
					</then>
					<elseif>
						<equals arg1="${database.type}" arg2="mariadb" />
						<then>
							<replace file="${app.server.lib.global.dir}/module.xml">
								<replacetoken><![CDATA[<resource-root path="hsql.jar" />]]></replacetoken>
								<replacevalue>
									<![CDATA[
										<resource-root path="hsql.jar" />
										<resource-root path="mariadb.jar" />
									]]>
								</replacevalue>
							</replace>
						</then>
					</elseif>
					<elseif>
						<equals arg1="${database.type}" arg2="oracle" />
						<then>
							<replace file="${app.server.lib.global.dir}/module.xml">
								<replacetoken><![CDATA[<resource-root path="hsql.jar" />]]></replacetoken>
								<replacevalue>
									<![CDATA[
										<resource-root path="hsql.jar" />
										<resource-root path="ojdbc6.jar" />
									]]>
								</replacevalue>
							</replace>
						</then>
					</elseif>
					<else>
						<replace file="${app.server.lib.global.dir}/module.xml">
							<replacetoken><![CDATA[<resource-root path="hsql.jar" />]]></replacetoken>
							<replacevalue>
								<![CDATA[
									<resource-root path="hsql.jar" />
									<resource-root path="mysql.jar" />
								]]>
							</replacevalue>
						</replace>
					</else>
				</if>
			</then>
		</if>
	</target>

	<target name="curl-execute">
		<fail message="Please set the property ${curl.args}." unless="curl.args" />

		<exec executable="curl">
			<arg line="${curl.args}" />
		</exec>
	</target>

	<target name="delete-liferay-home">
		<if>
			<not>
				<equals arg1="${delete.liferay.home}" arg2="false" />
			</not>
			<then>
				<if>
					<not>
						<isset property="test.app.server.liferay.home" />
					</not>
					<then>
						<set-app-server-properties />
					</then>
				</if>

				<delete failonerror="false" includeemptydirs="true">
					<fileset dir="${test.app.server.liferay.home}/data">
						<exclude name="hypersonic/lportal.properties" if:true="${keep.hypersonicdb}" />
						<exclude name="hypersonic/lportal.script" if:true="${keep.hypersonicdb}" />
					</fileset>
				</delete>
				<delete dir="${test.app.server.liferay.home}/logs" />
				<delete dir="${test.app.server.liferay.home}/osgi/state" />

				<delete file="${test.app.server.liferay.home}/portal-setup-wizard.properties" />
			</then>
		</if>

		<delete dir="/tmp/sprite" />
	</target>

	<target name="deploy-dependency-jars">
		<get-testcase-property property.name="liferay.training.dependency.jars" />

		<if>
			<isset property="liferay.training.dependency.jars" />
			<then>
				<for list="${liferay.training.dependency.jars}" param="liferay.training.dependency.jar">
					<sequential>
						<local name="training.dependency.file.name" />

						<basename file="${liferay.training.dir}/@{liferay.training.dependency.jar}" property="training.dependency.file.name" />

						<echo>Copying ${liferay.training.dir}/@{liferay.training.dependency.jar} to ${liferay.home}/deploy/${training.dependency.file.name}.</echo>

						<copy file="${liferay.training.dir}/@{liferay.training.dependency.jar}" todir="${liferay.home}/deploy" />
					</sequential>
				</for>
			</then>
		</if>
	</target>

	<target name="deploy-extra-apps">
		<get-testcase-property property.name="extraapps.plugins.includes" />

		<if>
			<isset property="extraapps.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-extra-apps">
					<property name="plugins.includes" value="${extraapps.plugins.includes}" />
				</ant>
			</then>
		</if>
	</target>

	<target name="deploy-latest-marketplace-apps">
		<if>
			<available file="${liferay.home}/osgi/marketplace" />
			<then>
				<for param="app.file.path">
					<path>
						<fileset dir="${liferay.home}/osgi/marketplace">
							<include name="*.lpkg" />
						</fileset>
					</path>
					<sequential>
						<local name="app.file.name" />

						<propertyregex
							input="@{app.file.path}"
							override="true"
							property="app.file.name"
							regexp=".*[/\\]marketplace[/\\](.+\.lpkg)"
							replace="\1"
						/>

						<local name="sync.connector.override" />

						<if>
							<matches pattern="https?://" string="${test.build.fix.pack.zip.url}" />
							<then>
								<get-fixpack-version patch.file.zip.url="${test.build.fix.pack.zip.url}" />

								<beanshell>
									<![CDATA[
										String appFileName = project.getProperty("app.file.name");
										String fixpackVersion = project.getProperty("fixpack.version");

										if (appFileName.equals("Liferay Sync Connector.lpkg") && (fixpackVersion != null)) {
											int fixpackVersionInt = Integer.valueOf(fixpackVersion);

											if (fixpackVersionInt < 19) {
												project.setProperty("sync.connector.override", "false");
											}
										}
									]]>
								</beanshell>
							</then>
						</if>

						<if>
							<and>
								<available file="${project.dir}/plugins/marketplace/${app.file.name}" />
								<not>
									<contains string="${test.latest.marketplace.apps.exclude}" substring="${app.file.name}" />
								</not>
								<not>
									<equals arg1="${sync.connector.override}" arg2="false" />
								</not>
							</and>
							<then>
								<echo>Copying ${project.dir}/plugins/marketplace/${app.file.name} to ${liferay.home}/osgi/marketplace/${app.file.name}.</echo>

								<delete file="${liferay.home}/osgi/marketplace/${app.file.name}" />

								<copy file="${project.dir}/plugins/marketplace/${app.file.name}" tofile="${liferay.home}/osgi/marketplace/${app.file.name}" />
							</then>
						</if>
					</sequential>
				</for>

				<for list="${test.latest.marketplace.apps.include}" param="app.file.name">
					<sequential>
						<if>
							<available file="${project.dir}/plugins/marketplace/@{app.file.name}" />
							<then>
								<echo>Copying ${project.dir}/plugins/marketplace/@{app.file.name} to ${liferay.home}/osgi/marketplace/@{app.file.name}.</echo>

								<delete failonerror="false" file="${liferay.home}/osgi/marketplace/@{app.file.name}" />

								<copy file="${project.dir}/plugins/marketplace/@{app.file.name}" tofile="${liferay.home}/osgi/marketplace/@{app.file.name}" />
							</then>
						</if>
					</sequential>
				</for>
			</then>
		</if>
	</target>

	<target name="deploy-lcs-environment-token">
		<get-testcase-property property.name="app.server.bundles.size" />

		<if>
			<isset property="app.server.bundles.size" />
			<then>
				<var name="app.server.bundle.index" value="1" />

				<antelope:repeat count="${app.server.bundles.size}">
					<var name="test.app.server.parent.dir" value="${app.server.parent.dir}-${app.server.bundle.index}" />

					<copy todir="${test.app.server.parent.dir}/data">
						<fileset dir="${selenium.output.dir.name}" includes="lcs-aatf-*.aatf" />
					</copy>

					<math
						datatype="int"
						operand1="${app.server.bundle.index}"
						operand2="1"
						operation="+"
						result="app.server.bundle.index"
					/>
				</antelope:repeat>

				<var name="app.server.bundle.index" unset="true" />
				<var name="test.app.server.parent.dir" unset="true" />
			</then>
		</if>

		<move todir="${app.server.parent.dir}/data">
			<fileset dir="${selenium.output.dir.name}" includes="lcs-aatf-*.aatf" />
		</move>
	</target>

	<target name="deploy-license-xml">
		<if>
			<matches pattern="https?://" string="${test.build.license.xml.zip.url}" />
			<then>
				<mkdir dir="${liferay.home}/deploy" />

				<mirrors-get
					dest="${liferay.home}/deploy/license.xml"
					src="${test.build.license.xml.zip.url}"
				/>
			</then>
		</if>
	</target>

	<target name="deploy-osgi-apps">
		<get-testcase-property property.name="osgi.app.includes" />

		<if>
			<isset property="osgi.app.includes" />
			<then>
				<for list="${osgi.app.includes}" param="osgi.app.name">
					<sequential>
						<antelope:stringutil property="osgi.app.name" string="@{osgi.app.name}">
							<antelope:trim />
						</antelope:stringutil>

						<for param="app.dir">
							<path>
								<dirset dir="modules">
									<include name="apps/${osgi.app.name}" />
									<include name="private/apps/${osgi.app.name}" />
								</dirset>
							</path>
							<sequential>
								<local name="Liferay-Releng-App-Title" />

								<property file="@{app.dir}/app.bnd" />

								<if>
									<available file="${liferay.home}/osgi/marketplace/${Liferay-Releng-App-Title}.lpkg" />
									<then>
										<delete file="${liferay.home}/osgi/marketplace/${Liferay-Releng-App-Title}.lpkg" />
									</then>
								</if>

								<if>
									<available file="${project.dir}/plugins/dist/${Liferay-Releng-App-Title}.lpkg" />
									<then>
										<echo>Copying ${project.dir}/plugins/dist/${Liferay-Releng-App-Title}.lpkg to ${liferay.home}/osgi/marketplace/${Liferay-Releng-App-Title}.lpkg.</echo>

										<copy file="${project.dir}/plugins/dist/${Liferay-Releng-App-Title}.lpkg" tofile="${liferay.home}/osgi/marketplace/${Liferay-Releng-App-Title}.lpkg" />
									</then>
									<elseif>
										<available file="${project.dir}/plugins/marketplace/${Liferay-Releng-App-Title}.lpkg" />
										<then>
											<echo>Copying ${project.dir}/plugins/marketplace/${Liferay-Releng-App-Title}.lpkg to ${liferay.home}/osgi/marketplace/${Liferay-Releng-App-Title}.lpkg.</echo>

											<copy file="${project.dir}/plugins/marketplace/${Liferay-Releng-App-Title}.lpkg" tofile="${liferay.home}/osgi/marketplace/${Liferay-Releng-App-Title}.lpkg" />
										</then>
									</elseif>
									<else>
										<echo>Deploying all relevant modules that make up ${Liferay-Releng-App-Title}.lpkg.</echo>

										<for param="module.dir.path">
											<path>
												<dirset dir="@{app.dir}">
													<include name="*" />
												</dirset>
											</path>
											<sequential>
												<basename file="@{module.dir.path}" property="module.war.name" />

												<delete failonerror="false" verbose="true">
													<fileset dir="${liferay.home}/deploy">
														<include name="${module.war.name}*" />
													</fileset>
												</delete>
											</sequential>
										</for>

										<gradle-execute dir="@{app.dir}" task="deploy">
											<arg value="clean" />
										</gradle-execute>

										<ant antfile="build.xml" dir="modules" target="build-app-lpkg">
											<property name="app.name" value="${osgi.app.name}" />
											<property name="osgi.dir" value="${liferay.home}/osgi" />
										</ant>

										<gradle-execute dir="@{app.dir}" task="clean" />
									</else>
								</if>
							</sequential>
						</for>
					</sequential>
				</for>
			</then>
		</if>
	</target>

	<target name="deploy-osgi-module-configurations">
		<var name="osgi.module.configurations.index" value="1" />

		<get-testcase-property property.name="osgi.module.configurations" />

		<for list="${osgi.module.configurations}" param="configuration">
			<sequential>
				<echo file="${liferay.home}/osgi/configs/${osgi.module.configurations.index}">@{configuration}</echo>

				<math
					datatype="int"
					operand1="${osgi.module.configurations.index}"
					operand2="1"
					operation="+"
					result="osgi.module.configurations.index"
				/>
			</sequential>
		</for>

		<var name="osgi.module.configuration.file.names.index" value="1" />

		<get-testcase-property property.name="osgi.module.configuration.file.names" />

		<for list="${osgi.module.configuration.file.names}" param="file.names">
			<sequential>
				<if>
					<available file="${liferay.home}/osgi/configs/${osgi.module.configuration.file.names.index}" />
					<then>
						<move
							file="${liferay.home}/osgi/configs/${osgi.module.configuration.file.names.index}"
							tofile="${liferay.home}/osgi/configs/@{file.names}"
						/>

						<math
							datatype="int"
							operand1="${osgi.module.configuration.file.names.index}"
							operand2="1"
							operation="+"
							result="osgi.module.configuration.file.names.index"
						/>
					</then>
				</if>
			</sequential>
		</for>
	</target>

	<target name="deploy-osgi-modules">
		<get-testcase-property property.name="osgi.modules.includes" />

		<if>
			<isset property="osgi.modules.includes" />
			<then>
				<echo file="tools/sdk/build.${user.name}.properties">auto.deploy.dir=${liferay.home}/deploy</echo>

				<local name="osgi.module.pattern" />

				<property name="osgi.module.pattern" value="**/apps/**" />

				<antelope:stringutil property="osgi.modules.includes.pattern" string="${osgi.module.pattern}/${osgi.modules.includes}">
					<antelope:replace regex="," replacement=",${osgi.module.pattern}/" />
				</antelope:stringutil>

				<pathconvert pathsep="," property="osgi.modules.paths">
					<dirset dir="modules" includes="${osgi.modules.includes.pattern}">
						<or>
							<present targetdir="modules">
								<mapper from="*" to="*/build.gradle" type="glob" />
							</present>
							<present targetdir="modules">
								<mapper from="*" to="*/build.xml" type="glob" />
							</present>
						</or>
					</dirset>
				</pathconvert>

				<for list="${osgi.modules.paths}" parallel="true" param="osgi.module.path">
					<sequential>
						<local name="module.base.dir" />
						<local name="osgi.module.command.prefix" />

						<dirname file="@{osgi.module.path}" property="module.base.dir" />

						<move failonerror="false" file="${module.base.dir}/settings.gradle" tofile="${module.base.dir}/settings.gradle.temp" verbose="true" />

						<gradle-execute dir="@{osgi.module.path}" forcedcacheenabled="false" task="deploy">
							<arg value="clean" />
						</gradle-execute>

						<move failonerror="false" file="${module.base.dir}/settings.gradle.temp" tofile="${module.base.dir}/settings.gradle" />
					</sequential>
				</for>
			</then>
		</if>
	</target>

	<target name="deploy-specified-plugins">

		<!--
		Deploy plugin files to the deploy directory.
		-->

		<get-testcase-property property.name="ext.plugins.includes" />

		<if>
			<isset property="ext.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="ext" />
					<property name="plugins.includes" value="${ext.plugins.includes}" />
				</ant>
			</then>
		</if>

		<get-testcase-property property.name="hook.plugins.includes" />

		<if>
			<isset property="hook.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="hooks" />
					<property name="plugins.includes" value="${hook.plugins.includes}" />
				</ant>
			</then>
		</if>

		<get-testcase-property property.name="layouttpl.plugins.includes" />

		<if>
			<isset property="layouttpl.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="layouttpl" />
					<property name="plugins.includes" value="${layouttpl.plugins.includes}" />
				</ant>
			</then>
		</if>

		<get-testcase-property property.name="portlet.plugins.includes" />

		<if>
			<isset property="portlet.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="portlets" />
					<property name="plugins.includes" value="${portlet.plugins.includes}" />
				</ant>
			</then>
		</if>

		<if>
			<equals arg1="${test.pacl}" arg2="true" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="portlets" />
					<property name="plugins.includes" value="chat-portlet,flash-portlet,portal-compat-hook,sample-service-builder-portlet,test-pacl-portlet" />
				</ant>
			</then>
		</if>

		<get-testcase-property property.name="theme.plugins.includes" />

		<if>
			<isset property="theme.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="themes" />
					<property name="plugins.includes" value="${theme.plugins.includes}" />
				</ant>
			</then>
		</if>

		<get-testcase-property property.name="web.plugins.includes" />

		<if>
			<isset property="web.plugins.includes" />
			<then>
				<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
					<property name="plugin.types" value="webs" />
					<property name="plugins.includes" value="${web.plugins.includes}" />
				</ant>
			</then>
		</if>
	</target>

	<target name="deploy-sql-zip">
		<if>
			<matches pattern="https?://" string="${test.sql.zip.url}" />
			<then>
				<mirrors-get
					dest="sql/release-sql.zip"
					src="${test.sql.zip.url}"
				/>

				<unzip dest="sql/" src="sql/release-sql.zip">
					<patternset
						includes="liferay-*/**"
					/>
					<mapper
						from="[^/]+/(create.*)"
						to="\1"
						type="regexp"
					/>
				</unzip>
			</then>
		</if>
	</target>

	<target name="generate-backup-results-xml">
		<if>
			<and>
				<isset property="env.JENKINS_HOME" />
				<isset property="jenkins.shared.user.content.dir" />
			</and>
			<then>
				<if>
					<isset property="test.class" />
					<then>
						<antcall target="record-test-generated-properties" />

						<property file="test.generated.properties" />

						<get-test-class-name />

						<if>
							<contains string="${test.class}" substring="#" />
							<then>
								<get-test-method-name />
							</then>
							<else>
								<property name="test.method.name" value="" />
							</else>
						</if>
					</then>
				</if>

				<if>
					<isset property="group.index" />
					<then>
						<propertyregex
							input="${group.index}"
							override="true"
							property="group.index"
							regexp="[\w\.]+\.(\w+)"
							replace="\1"
						/>

						<property name="results.xml.file" value="portal-web/test-results/functional/TEST-${env.BUILD_FLOW_JOB_NAME}_${env.BUILD_FLOW_BUILD_NUMBER}_${testray.main.component.name}_${group.index}.xml" />
					</then>
					<elseif>
						<isset property="test.class" />
						<then>
							<property name="results.xml.file" value="portal-web/test-results/functional/TEST-${env.BUILD_FLOW_JOB_NAME}_${env.BUILD_FLOW_BUILD_NUMBER}_${test.class}.xml" />
						</then>
					</elseif>
					<else>
						<property name="results.xml.file" value="portal-web/test-results/functional/TEST-${env.BUILD_FLOW_JOB_NAME}_${env.BUILD_FLOW_BUILD_NUMBER}_${testray.main.component.name}.xml" />
					</else>
				</if>

				<if>
					<equals arg1="${build.status}" arg2="pass" />
					<then>
						<property name="testcase.element"><![CDATA[<testcase classname="${test.class.name}" name="${test.method.name}" time="0.00" />]]></property>
					</then>
					<else>
						<property name="testcase.element"><![CDATA[
							<testcase classname="${test.class.name}" name="${test.method.name}" time="0.00">
								<failure message="Jenkins failure prior to running test.">Jenkins failure prior to running test.</failure>
							</testcase>
						]]></property>
					</else>
				</if>

				<echo file="${results.xml.file}"><![CDATA[<?xml version="1.0"?>

<testsuite>
	${testcase.element}
	<system-out></system-out>
	<system-err></system-err>
</testsuite>]]></echo>

				<antcall target="build-test-results-xml" />

				<copy flatten="true" todir="${jenkins.shared.user.content.dir}/jobs/${env.BUILD_FLOW_JOB_NAME}/builds/${env.BUILD_FLOW_BUILD_NUMBER}/test-results">
					<fileset dir="modules" erroronmissingdir="false">
						<include name="**/TEST-*.xml" />
					</fileset>
					<fileset dir="portal-impl/test-results" erroronmissingdir="false">
						<include name="**/TEST-*.xml" />
					</fileset>
					<fileset dir="portal-kernel/test-results" erroronmissingdir="false">
						<include name="**/TEST-*.xml" />
					</fileset>
					<fileset dir="portal-web/test-results" erroronmissingdir="false">
						<include name="**/TEST-*.xml" />
					</fileset>
					<fileset dir="util-java/test-results" erroronmissingdir="false">
						<include name="**/TEST-*.xml" />
					</fileset>
				</copy>
			</then>
		</if>
	</target>

	<target name="generate-changelog">
		<record-git-commit-plugins />
		<record-git-commit-portal />

		<tstamp>
			<format pattern="EEEE, d MMMM yyyy, hh:mm aa" property="build.tstamp.value" />
		</tstamp>

		<property
			name="changelog.dir"
			value="${env.JENKINS_HOME}/userContent/jobs/${env.JOB_NAME}/builds/${env.BUILD_NUMBER}"
		/>

		<math
			datatype="int"
			operand1="${env.BUILD_NUMBER}"
			operand2="1"
			operation="-"
			result="previous.build.number"
		/>

		<property
			name="previous.changelog.dir"
			value="${env.JENKINS_HOME}/userContent/jobs/${env.JOB_NAME}/builds/${previous.build.number}"
		/>

		<if>
			<and>
				<available file="${previous.changelog.dir}/git-build-log.html" />
				<available file="${previous.changelog.dir}/git-commit-plugins" />
				<available file="${previous.changelog.dir}/git-commit-portal" />
			</and>
			<then>
				<loadfile
					property="previous.git.commit.plugins.rev.parse"
					srcfile="${previous.changelog.dir}/git-commit-plugins"
				/>

				<loadfile
					property="previous.git.commit.portal.rev.parse"
					srcfile="${previous.changelog.dir}/git-commit-portal"
				/>

				<copy
					file="${previous.changelog.dir}/git-build-log.html"
					tofile="${changelog.dir}/git-build-log.html"
				/>

				<if>
					<equals arg1="${git.commit.plugins.rev.parse}" arg2="${previous.git.commit.plugins.rev.parse}" />
					<then>
						<property
							name="git.log.content.plugins"
							value="No Changes"
						/>
					</then>
					<else>
						<execute dir="${lp.plugins.dir}">
							<![CDATA[git log --pretty=format:'<a href="https://github.com/liferay/liferay-plugins-ee/commit/'%H'" target="_blank">'%H'</a>''<br />'%an'<br />'%s'<br /><br />' ${previous.git.commit.plugins.rev.parse}...${git.commit.plugins.rev.parse} > ${changelog.dir}/git.log]]>
						</execute>

						<loadfile
							property="git.log.content.plugins"
							srcfile="${changelog.dir}/git.log"
						/>
					</else>
				</if>

				<if>
					<equals arg1="${git.commit.portal.rev.parse}" arg2="${previous.git.commit.portal.rev.parse}" />
					<then>
						<property
							name="git.log.content.portal"
							value="No Changes"
						/>
					</then>
					<else>
						<execute dir="${project.dir}">
							<![CDATA[git log --pretty=format:'<a href="https://github.com/liferay/liferay-portal-ee/commit/'%H'" target="_blank">'%H'</a>''<br />'%an'<br />'%s'<br /><br />' ${previous.git.commit.portal.rev.parse}...${git.commit.portal.rev.parse} > ${changelog.dir}/git.log]]>
						</execute>

						<loadfile
							property="git.log.content.portal"
							srcfile="${changelog.dir}/git.log"
						/>
					</else>
				</if>

				<replace file="${changelog.dir}/git-build-log.html">
					<replacetoken><![CDATA[<!-- NEXT -->]]></replacetoken>
					<replacevalue expandproperties="true"><![CDATA[<!-- NEXT -->

		<div id="updateWrapper">
			<div class="divider"></div>
			<div id="update">
				<h2>
					Build #${env.BUILD_NUMBER} - ${env.JOB_NAME} - ${build.tstamp.value}<br />
					Portal: ${git.commit.portal.rev.parse}<br />
					Plugins: ${git.commit.plugins.rev.parse}
				</h2>

				<div id="portal">
					<h4>
						Portal Git Log:
					</h4>
					<p>
						${git.log.content.portal}
					</p>
				</div>

				<div id="plugins">
					<h4>
						Plugins Git Log:
					</h4>
					<p>
						${git.log.content.plugins}
					</p>
				</div>
			</div>
		</div>
				]]></replacevalue>
				</replace>
			</then>
			<else>
				<echo file="${changelog.dir}/git-build-log.html"><![CDATA[<!DOCTYPE html>
<html>
	<head>
		<title>Git Build Log</title>
		<style>
			body {
				font-family: Helvetica, Arial, sans-serif;
				margin: 5%;
				padding: 0;
			}

			h2 {
				font-size: 17px;
				letter-spacing: 0.04em;
			}

			h4 {
				border-left: 1px solid #BABABA;
				color: #555;
				font-size: 20px;
				font-weight: 100;
				line-height: 30px;
				margin: 20px 20px 0;
				padding: 0 0 20px 10px;
			}

			p {
				font-size: 12px;
			}

			#updateWrapper:after {
				clear: both;
				content: "";
				display: table;
			}

			#update h2 {
				background-color: #4D9CD1;
				color: #FFF;
				padding: 15px;
			}

			.divider {
				background-color: #999;
				box-shadow: 0px 0px 2px 0px rgba(0, 0, 0, 0.5);
				-moz-box-shadow: 0px 0px 2px 0px rgba(0, 0, 0, 0.5);
				-webkit-box-shadow: 0px 0px 2px 0px rgba(0, 0, 0, 0.5);
				height: 1px;
				margin: 15px 0 25px;
				width: 100%;
			}

			#plugins {
				float: right;
			}

			#portal {
				float: left;
			}

			#plugins, #portal {
				width: 48%;
			}

			#plugins p, #portal p {
				border-radius: 8px;
				-moz-border-radius: 8px;
				-webkit-border-radius: 8px;
				box-shadow: inset 0px 1px 6px -1px rgba(0, 0, 0, 0.5);
				-moz-box-shadow: inset 0px 1px 6px -1px rgba(0, 0, 0, 0.5);
				-webkit-box-shadow: inset 0px 1px 6px -1px rgba(0, 0, 0, 0.5);
				margin-top: 0;
				padding: 10px;
				word-wrap: break-word;
			}

			#plugins a, #portal a {
				color: #3D7CA6;
				font-family: Monaco, "Liberation Mono", Courier, monospace;
				font-weight: bold;
				text-decoration: none;
			}

			#plugins a:hover, #portal a:hover {
				text-decoration: underline;
			}
		</style>
	</head>
	<body>

		<!-- NEXT -->

		<div id="updateWrapper">
			<div class="divider"></div>

			<br />

			<div id="update">
				<h2>
					Initial Commit<br />
					Build #${env.BUILD_NUMBER} - ${env.JOB_NAME} - ${build.tstamp.value}<br />
					Portal: ${git.commit.portal.rev.parse}<br />
					Plugins: ${git.commit.plugins.rev.parse}
				</h2>
			</div>
		</div>
	</body>
</html>
				]]></echo>
			</else>
		</if>

		<copy
			file="${changelog.dir}/git-build-log.html"
			todir="${basedir}"
		/>

		<copy
			file="${changelog.dir}/git-build-log.html"
			todir="${env.JENKINS_HOME}/userContent/jobs/${env.JOB_NAME}/builds/${env.BUILD_NUMBER}"
		/>
	</target>

	<target name="install-patch">
		<fail message="Please set the property ${patch.file.zip.url}." unless="patch.file.zip.url" />

		<install-patch patching.tool.dir="${app.server.parent.dir}/patching-tool" patch.file.zip.url="${patch.file.zip.url}" />
	</target>

	<target name="kill-spi">
		<if>
			<os family="unix" />
			<then>
				<execute>
					kill -9 pgrep -n java
				</execute>
			</then>
			<else>
				<execute>
					taskkill.exe /F /FI "imagename eq java.exe" /FI "memusage lt 700000" /FI "memusage gt 600000"
				</execute>
			</else>
		</if>
	</target>

	<target name="merge-jenkins-test-results">
		<property name="jenkins.test.results.dir" value="${env.JENKINS_HOME}/userContent/jobs/${env.BUILD_FLOW_JOB_NAME}/builds/${env.BUILD_FLOW_BUILD_NUMBER}/test-results" />

		<property name="jenkins.results.xml.suite.file" value="${jenkins.test.results.dir}/test-suite/TESTS-${env.BUILD_FLOW_JOB_NAME}_${env.BUILD_FLOW_BUILD_NUMBER}.xml" />

		<first id="first">
			<fileset dir="${jenkins.test.results.dir}" includes="*.xml" />
		</first>

		<loadfile property="jenkins.results.xml.suite.file.header" srcfile="${toString:first}" />

		<propertyregex
			input="${jenkins.results.xml.suite.file.header}"
			override="true"
			property="jenkins.results.xml.suite.file.header"
			regexp="&lt;testcase[\s\S.]*"
			replace=""
		/>

		<propertyregex
			input="${jenkins.results.xml.suite.file.header}"
			override="true"
			property="jenkins.results.xml.suite.file.header"
			regexp="&lt;testsuite.*\n"
			replace="&lt;testsuite&gt;${line.separator}"
		/>

		<echo file="${jenkins.results.xml.suite.file}">${jenkins.results.xml.suite.file.header}</echo>

		<for param="jenkins.results.xml.file">
			<path>
				<fileset dir="${jenkins.test.results.dir}">
					<include name="*.xml" />
				</fileset>
			</path>
			<sequential>
				<echo>Merging @{jenkins.results.xml.file}.</echo>

				<var name="jenkins.results.xml.suite.file.body" unset="true" />

				<loadfile property="jenkins.results.xml.suite.file.body" srcfile="@{jenkins.results.xml.file}" />

				<propertyregex
					input="${jenkins.results.xml.suite.file.body}"
					override="true"
					property="jenkins.results.xml.suite.file.body"
					regexp="&lt;\?xml[\s\S]*?&lt;testcase"
					replace="&lt;testcase"
				/>

				<propertyregex
					input="${jenkins.results.xml.suite.file.body}"
					override="true"
					property="jenkins.results.xml.suite.file.body"
					regexp="&lt;/testcase&gt;[\s\S]*"
					replace="&lt;/testcase&gt;${line.separator}"
				/>

				<echo append="true" file="${jenkins.results.xml.suite.file}">${jenkins.results.xml.suite.file.body}</echo>
			</sequential>
		</for>

		<echo append="true" file="${jenkins.results.xml.suite.file}">&lt;/testsuite&gt;</echo>

		<if>
			<contains string="${env.JOB_NAME}" substring="frontend" />
			<then>
				<copy file="${jenkins.results.xml.suite.file}" tofile="${env.WORKSPACE}/TEST-ConsolidatedResults.xml" />
			</then>
		</if>

		<beanshell>
			<![CDATA[
				import java.io.BufferedReader;
				import java.io.File;
				import java.io.IOException;

				BufferedReader bufferedReader = null;

				try {
					File jenkinsResultsXMLSuiteFile = new File(project.getProperty("jenkins.results.xml.suite.file"));

					bufferedReader = new BufferedReader(new FileReader(jenkinsResultsXMLSuiteFile));

					List lines = new ArrayList();

					int failCount = 0;
					int lineNumber = 0;
					int summaryLocation = 0;
					int totalCount = 0;

					for (String line = bufferedReader.readLine(); line != null; line = bufferedReader.readLine()) {
						lineNumber++;

						lines.add(line);

						if (line.contains("<failure")) {
							failCount++;
						}
						else if (line.contains("<testcase")) {
							totalCount++;
						}
						else if (line.contains("<testsuite")) {
							summaryLocation = lineNumber;
						}
					}

					bufferedReader.close();

					int passCount = totalCount - failCount;

					lines.add(summaryLocation, "\t</summary>");
					lines.add(summaryLocation, "\t\t<property name=\"failed\" value=\"" + Integer.toString(failCount) + "\" />");
					lines.add(summaryLocation, "\t\t<property name=\"passed\" value=\"" + Integer.toString(passCount) + "\" />");
					lines.add(summaryLocation, "\t<summary>");

					FileWriter fileWriter = new FileWriter(jenkinsResultsXMLSuiteFile);

					BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

					for (String line : lines) {
						bufferedWriter.write(line);
						bufferedWriter.write('\n');
					}

					bufferedWriter.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}
			]]>
		</beanshell>

		<if>
			<isset property="jenkins.testray.results.dir" />
			<then>
				<for list="production,uat" param="testray.base.dir.name">
					<sequential>
						<rsync rsync.dest="testray-results/@{testray.base.dir.name}" rsync.src="${jenkins.results.xml.suite.file}" />
					</sequential>
				</for>
			</then>
		</if>
	</target>

	<target name="merge-test-results">
		<mkdir dir="test-results" />

		<parallel timeout="1800000">
			<junitreport todir="test-results">
				<fileset dir="modules" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="portal-impl/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="portal-kernel/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="portal-web/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="util-java/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="${blade.samples.dir}/liferay-workspace/tests" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<fileset dir="${liferay.jenkins.dir}/commands/custom-scripts/test-results" erroronmissingdir="false">
					<include name="**/TEST-*.xml" />
				</fileset>
				<report format="frames" todir="test-results/html" />
			</junitreport>
		</parallel>

		<replaceregexp
			file="test-results/TESTS-TestSuites.xml"
			flags="g"
			match="\s*\&lt;/?propert[^\n^\r]*[\n\r]"
			replace=""
		/>

		<replaceregexp
			file="test-results/TESTS-TestSuites.xml"
			flags="g"
			match="&lt;system-out&gt;[\s\S]*?&lt;\/system-out&gt;"
			replace="&lt;system-out&gt;&lt;\/system-out&gt;"
		/>

		<replaceregexp
			file="test-results/TESTS-TestSuites.xml"
			flags="g"
			match="&lt;system-err&gt;[\s\S]*?&lt;\/system-err&gt;"
			replace="&lt;system-err&gt;&lt;\/system-err&gt;"
		/>

		<echo message="A report with all the test results can be found at test-results/html/index.html." />
	</target>

	<target name="move-file">
		<fail message="Please set the property ${file}." unless="file" />
		<fail message="Please set the property ${tofile}." unless="tofile" />

		<if>
			<available file="${file}" />
			<then>
				<move file="${file}" tofile="${tofile}" />

				<echo message="Moved file ${file} to ${tofile}." />
			</then>
			<else>
				<echo message="File ${file} does not exist." />
			</else>
		</if>
	</target>

	<target name="prepare-lcs-gateway-bundle">
		<ant antfile="build-dist.xml" inheritAll="false" target="unzip-tomcat">
			<property name="app.server.parent.dir" value="${app.server.parent.dir}/gateway" />
		</ant>

		<replaceregexp
			file="${app.server.parent.dir}/gateway/tomcat-${app.server.tomcat.version}/conf/server.xml"
			flags="g"
			match="=&quot;8(\d\d\d)&quot;"
			replace="=&quot;7\1&quot;"
		/>

		<copy
			file="${project.dir}/lib/portal/log4j.jar"
			tofile="${app.server.parent.dir}/gateway/tomcat-${app.server.tomcat.version}/lib/log4j.jar"
		/>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/gateway/plugins/webs/osb-lcs-gateway-web/docroot/WEB-INF/src/gateway-ext.properties"
			tofile="${lp.plugins.dir}/webs/osb-lcs-gateway-web/docroot/WEB-INF/src/gateway-ext.properties"
		/>

		<delete dir="${lp.plugins.dir}/dist" failonerror="false" />

		<property file="${lfrsite-lcs.dir}/jenkins/build.development.properties" />

		<ant dir="${lp.plugins.dir}" inheritAll="false" target="clean" />

		<ant dir="${lp.plugins.dir}" target="war" >
			<property name="plugins.includes" value="${plugins.includes.gateway}" />
		</ant>

		<copy todir="${app.server.parent.dir}/gateway/tomcat-${app.server.tomcat.version}/webapps">
			<fileset dir="${lp.plugins.dir}/dist" />
		</copy>
	</target>

	<target name="prepare-lcs-portal-bundle">
		<antcall target="prepare-portal-ext-properties" />

		<antcall inheritAll="false" target="rebuild-database" />

		<loadfile property="lcs.portal.bundle.properties" srcFile="${lfrsite-lcs.dir}/jenkins/development/portal/artifacts/liferay/portal-ext.properties" />

		<echo append="true" file="${app.server.classes.portal.dir}/portal-ext.properties">

${lcs.portal.bundle.properties}</echo>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/portal/artifacts/liferay/portal-log4j-ext.xml"
			tofile="${app.server.classes.global.dir}/portal-log4j-ext.xml"
		/>

		<replace file="${app.server.bin.dir}/setenv${file.suffix.bat}">
			<replacetoken><![CDATA[-Djava.net.preferIPv4Stack=true]]></replacetoken>
			<replacevalue><![CDATA[-Djava.net.preferIPv4Stack=true -Dportal:ldap.auth.search.filter=\"(&(mail=@email_address@)(member=cn=Liferay\5C, Inc.,ou=Organizations,ou=liferay.com,o=Liferay))\" -Dportal:ldap.import.user.search.filter=\"(&(objectClass=inetOrgPerson)(member=cn=Liferay\5C, Inc.,ou=Organizations,ou=liferay.com,o=Liferay))\"]]></replacevalue>
		</replace>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/portal/plugins/portlets/lcs-portlet/docroot/WEB-INF/src/META-INF/portal-log4j.xml"
			tofile="${lp.plugins.dir}/portlets/lcs-portlet/docroot/WEB-INF/src/META-INF/portal-log4j.xml"
		/>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/portal/plugins/portlets/lcs-portlet/docroot/WEB-INF/src/portlet-ext.properties"
			tofile="${lp.plugins.dir}/portlets/lcs-portlet/docroot/WEB-INF/src/portlet-ext.properties"
		/>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/portal/plugins/portlets/osb-lcs-portlet/docroot/WEB-INF/src/META-INF/portal-log4j.xml"
			tofile="${lp.plugins.dir}/portlets/osb-lcs-portlet/docroot/WEB-INF/src/META-INF/portal-log4j.xml"
		/>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/portal/plugins/portlets/osb-lcs-portlet/docroot/WEB-INF/src/portlet-ext.properties"
			tofile="${lp.plugins.dir}/portlets/osb-lcs-portlet/docroot/WEB-INF/src/portlet-ext.properties"
		/>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/portal/plugins/webs/file-repository-web/docroot/WEB-INF/web.xml"
			tofile="${lp.plugins.dir}/webs/file-repository-web/docroot/WEB-INF/web.xml"
		/>

		<property file="${lfrsite-lcs.dir}/jenkins/build.development.properties" />

		<ant dir="${lp.plugins.dir}" target="clean" />

		<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins">
			<property name="plugins.includes" value="${plugins.includes.portal}" />
		</ant>
	</target>

	<target name="prepare-lcs-portlet-bundle">
		<chmod perm="a+x">
			<fileset dir="${app.server.parent.dir}/patching-tool">
				<include name="*.sh" />
			</fileset>
		</chmod>

		<delete file="${app.server.parent.dir}/patching-tool/default.properties" />

		<execute dir="${app.server.parent.dir}/patching-tool">
			patching-tool${file.suffix.bat} auto-discovery
			patching-tool${file.suffix.bat} setup
		</execute>

		<replace file="${app.server.dir}/bin/setenv${file.suffix.bat}">
			<replacetoken><![CDATA[-XX:MaxPermSize=256m]]></replacetoken>
			<replacevalue><![CDATA[-XX:MaxPermSize=256m -javaagent:../../patching-tool/lib/patching-tool-agent.jar]]></replacevalue>
		</replace>

		<echo file="${lp.plugins.dir}/portlets/lcs-portlet/docroot/WEB-INF/src/portlet-ext.properties">#QA AWS

osb.lcs.gateway.web.host.name=${osb.lcs.gateway.web.host.name}
osb.lcs.gateway.web.host.port=${osb.lcs.gateway.web.host.port}

osb.lcs.portlet.host.name=${osb.lcs.portlet.host.name}
osb.lcs.portlet.host.port=${osb.lcs.portlet.host.port}

osb.lcs.portlet.oauth.consumer.key=${osb.lcs.portlet.oauth.consumer.key}
osb.lcs.portlet.oauth.consumer.secret=${osb.lcs.portlet.oauth.consumer.secret}</echo>

		<property name="plugins.includes" value="lcs-portlet" />

		<ant dir="${lp.plugins.dir}" target="clean" />

		<ant dir="${lp.plugins.dir}" target="compile" />

		<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins" />
	</target>

	<target name="prepare-lcs-processor-bundle">
		<ant antfile="build-dist.xml" inheritAll="false" target="unzip-tomcat">
			<property name="app.server.parent.dir" value="${app.server.parent.dir}/processor" />
		</ant>

		<replaceregexp
			file="${app.server.parent.dir}/processor/tomcat-${app.server.tomcat.version}/conf/server.xml"
			flags="g"
			match="=&quot;8(\d\d\d)&quot;"
			replace="=&quot;9\1&quot;"
		/>

		<copy
			file="${project.dir}/lib/portal/log4j.jar"
			tofile="${app.server.parent.dir}/processor/tomcat-${app.server.tomcat.version}/lib/log4j.jar"
		/>

		<copy
			file="${lfrsite-lcs.dir}/jenkins/development/processor/plugins/webs/osb-lcs-processor-web/docroot/WEB-INF/src/processor-ext.properties"
			tofile="${lp.plugins.dir}/webs/osb-lcs-processor-web/docroot/WEB-INF/src/processor-ext.properties"
		/>

		<delete dir="${lp.plugins.dir}/dist" failonerror="false" />

		<property file="${lfrsite-lcs.dir}/jenkins/build.development.properties" />

		<ant dir="${lp.plugins.dir}" inheritAll="false" target="clean" />

		<ant dir="${lp.plugins.dir}" target="war">
			<property name="plugins.includes" value="${plugins.includes.processor}" />
		</ant>

		<copy todir="${app.server.parent.dir}/processor/tomcat-${app.server.tomcat.version}/webapps">
			<fileset dir="${lp.plugins.dir}/dist" />
		</copy>
	</target>

	<target name="prepare-log4j-ext-xml">
		<var name="dialect.detector.log.level" value="INFO" />

		<if>
			<equals arg1="${database.type}" arg2="hypersonic" />
			<then>
				<var name="dialect.detector.log.level" value="ERROR" />
			</then>
		</if>

		<echo file="${app.server.classes.portal.dir}/META-INF/portal-log4j-ext.xml"><![CDATA[<?xml version="1.0"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
	<appender class="org.apache.log4j.ConsoleAppender" name="CONSOLE">
		<layout class="org.apache.log4j.EnhancedPatternLayout">
			<param name="ConversionPattern" value="%d{ABSOLUTE} %-5p [%t][%c{1}:%L] %m%n" />
		</layout>
	</appender>

	<appender class="org.apache.log4j.rolling.RollingFileAppender" name="TEXT_FILE">
		<rollingPolicy class="org.apache.log4j.rolling.TimeBasedRollingPolicy">
			<param name="FileNamePattern" value="@liferay.home@/logs/liferay@spi.id@.%d{yyyy-MM-dd}.log" />
		</rollingPolicy>

		<layout class="org.apache.log4j.EnhancedPatternLayout">
			<param name="ConversionPattern" value="%d{ABSOLUTE} %-5p [%t][%c{1}:%L] %m%n" />
		</layout>
	</appender>

	<appender class="org.apache.log4j.rolling.RollingFileAppender" name="XML_FILE">
		<rollingPolicy class="org.apache.log4j.rolling.TimeBasedRollingPolicy">
			<param name="FileNamePattern" value="@liferay.home@/logs/liferay@spi.id@.%d{yyyy-MM-dd}.xml" />
		</rollingPolicy>

		<layout class="org.apache.log4j.xml.XMLLayout">
			<param name="LocationInfo" value="true" />
		</layout>
	</appender>

	<category name="com.liferay.frontend.js.spa.web.internal.servlet.taglib">
		<priority value="DEBUG" />
	</category>

	<category name="com.liferay.portal.dao.orm.hibernate.VerifySessionFactoryWrapper">
		<priority value="INFO" />
	</category>

	<category name="com.liferay.portal.spring.hibernate.DialectDetector">
		<priority value="${dialect.detector.log.level}" />
	</category>

	<category name="com.liferay.portal.test.randomizerbumpers.TikaSafeRandomizerBumper">
		<priority value="INFO" />
	</category>

	<root>
		<priority value="INFO" />
		<appender-ref ref="CONSOLE" />
		<appender-ref ref="TEXT_FILE" />
		<appender-ref ref="XML_FILE" />
	</root>
</log4j:configuration>]]></echo>

		<echo file="${liferay.home}/osgi/log4j/com.liferay.portal.osgi.web.wab.generator-log4j-ext.xml"><![CDATA[<?xml version="1.0"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
	<category name="com.liferay.portal.osgi.web.wab.generator.internal.WabGenerator">
		<priority value="ERROR" />
	</category>

	<category name="com.liferay.portal.osgi.web.wab.generator.internal.processor.WabProcessor">
		<priority value="WARN" />
	</category>
</log4j:configuration>]]></echo>

		<echo file="${liferay.home}/osgi/log4j/com.liferay.portal.search.elasticsearch-log4j-ext.xml"><![CDATA[<?xml version="1.0"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
	<category name="com.liferay.portal.search.elasticsearch.internal.connection.EmbeddedElasticsearchConnection">
		<priority value="ERROR" />
	</category>
</log4j:configuration>]]></echo>
	</target>

	<target name="prepare-mobile-device">
		<stop-android-device />

		<start-android-device />
	</target>

	<target name="prepare-osgi-module-configurations">
		<get-testcase-property property.name="osgi.module.configurations" />

		<if>
			<not>
				<contains string="${osgi.module.configurations}" substring="maxChallenges" />
			</not>
			<then>
				<prepare-captcha-configuration />
			</then>
		</if>

		<get-testcase-property property.name="testray.main.component.name" />

		<if>
			<not>
				<contains string="${testray.main.component.name}" substring="Elastic Search Impl" />
			</not>
			<then>
				<prepare-elasticsearch-configuration />
			</then>
		</if>
	</target>

	<target name="prepare-patching-tool">
		<prepare-patching-tool patching.tool.dir="${app.server.parent.dir}/patching-tool" />
	</target>

	<target name="prepare-portal-ext-properties">
		<delete file="portal-impl/src/portal-ext.properties" />

		<if>
			<and>
				<isset property="test.base.dir.name" />
				<available file="${test.base.dir.name}/portal.properties" />
			</and>
			<then>
				<copy file="${test.base.dir.name}/portal.properties" tofile="portal-impl/src/portal-ext.properties" />
			</then>
		</if>

		<get-database-property property.name="database.driver" />
		<get-database-property property.name="database.password" />
		<get-database-property property.name="database.url" />
		<get-database-property property.name="database.username" />
		<get-database-property property.name="database.version" />

		<echo append="true" file="portal-impl/src/portal-ext.properties">

liferay.home=${liferay.home}

plugin.notifications.enabled=false

jdbc.default.jndi.name=

jdbc.default.driverClassName=${database.driver}
jdbc.default.url=${database.url}
jdbc.default.username=${database.username}
jdbc.default.password=${database.password}

// HikariCP

jdbc.default.connectionTimeout=600000
jdbc.default.maximumPoolSize=20
jdbc.default.minimumIdle=0

jdbc.counter.maximumPoolSize=5
jdbc.counter.minimumIdle=0

// Tomcat

jdbc.default.initialSize=0
jdbc.default.maxActive=20
jdbc.default.maxIdle=0
jdbc.default.minIdle=0

jdbc.counter.initialSize=0
jdbc.counter.maxActive=5
jdbc.counter.maxIdle=0
jdbc.counter.minIdle=0

browser.launcher.url=

index.on.startup=true

setup.wizard.enabled=false

mail.session.jndi.name=

sprite.root.dir=/tmp/sprite

memory.scheduler.org.quartz.threadPool.threadCount=1

persisted.scheduler.org.quartz.threadPool.threadCount=1

virtual.hosts.default.site.name=

axis.servlet.hosts.allowed=

tunnel.servlet.hosts.allowed=</echo>

		<if>
			<equals arg1="${database.type}" arg2="oracle" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties"><![CDATA[
jdbc.default.connectionProperties=oracle.jdbc.ReadTimeout=0;oracle.net.CONNECT_TIMEOUT=0]]></echo>
			</then>
		</if>

		<get-testcase-property property.name="cluster.enabled" />

		<if>
			<equals arg1="${cluster.enabled}" arg2="true" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties">

cluster.link.autodetect.address=

cluster.link.enabled=true

dl.store.impl=com.liferay.portal.store.db.DBStore

web.server.display.node=true</echo>
			</then>
		</if>

		<get-testcase-property property.name="custom.properties" />

		<if>
			<isset property="custom.properties" />
			<then>
				<prepare-custom-properties custom.properties="${custom.properties}" />
			</then>
		</if>

		<get-testcase-property property.name="database.jndi.enabled" />

		<if>
			<equals arg1="${database.jndi.enabled}" arg2="true" />
			<then>
				<replace file="portal-impl/src/portal-ext.properties">
					<replacetoken>jdbc.default.jndi.name=</replacetoken>
					<replacevalue>jdbc.default.jndi.name=jdbc/LiferayPool</replacevalue>
				</replace>
			</then>
		</if>

		<if>
			<equals arg1="${database.type}" arg2="db2" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties">

hibernate.dialect=com.liferay.portal.dao.orm.hibernate.DB2Dialect
custom.sql.function.isnull=CAST(? AS VARCHAR(32672)) IS NULL
custom.sql.function.isnotnull=CAST(? AS VARCHAR(32672)) IS NOT NULL</echo>
			</then>
			<elseif>
				<equals arg1="${database.type}" arg2="sybase" />
				<then>
					<echo append="true" file="portal-impl/src/portal-ext.properties">

hibernate.dialect=org.hibernate.dialect.SybaseDialect
custom.sql.function.isnull=CONVERT(VARCHAR,?) IS NULL
custom.sql.function.isnotnull=CONVERT(VARCHAR,?) IS NOT NULL</echo>
				</then>
			</elseif>
		</if>

		<if>
			<and>
				<equals arg1="${database.type}" arg2="oracle" />
				<equals arg1="${database.version}" arg2="11.2.0.1.0" />
			</and>
			<then>
				<replaceregexp
					file="portal-impl/src/portal-ext.properties"
					match="(jdbc:oracle:.*)oracl"
					replace="\1xe"
				/>
			</then>
		</if>

		<if>
			<equals arg1="${hot.deploy.dependency.management.enabled}" arg2="false" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties">

hot.deploy.dependency.management.enabled=false</echo>
			</then>
		</if>

		<get-testcase-property property.name="index.on.startup" />

		<if>
			<equals arg1="${index.on.startup}" arg2="false" />
			<then>
				<replace file="portal-impl/src/portal-ext.properties">
					<replacetoken>index.on.startup=true</replacetoken>
					<replacevalue>index.on.startup=false</replacevalue>
				</replace>
			</then>
		</if>

		<if>
			<equals arg1="${java.security}" arg2="true" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties">

portal.security.manager.strategy=liferay</echo>
			</then>
		</if>

		<if>
			<equals arg1="${javascript.fast.load}" arg2="false" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties">

javascript.fast.load=false</echo>
			</then>
		</if>

		<get-testcase-property property.name="blacklist.portal.profile.names.remove" />

		<if>
			<isset property="blacklist.portal.profile.names.remove" />
			<then>
				<beanshell>
					<![CDATA[
						StringBuilder sb = new StringBuilder();

						String blacklistPortalProfileNamesString = project.getProperty("blacklist.portal.profile.names");

						List blacklistPortalProfileNames = new ArrayList(Arrays.asList(blacklistPortalProfileNamesString.split(",")));

						String blacklistPortalProfileNamesRemoveString = project.getProperty("blacklist.portal.profile.names.remove");

						List blacklistPortalProfileNamesRemove = new ArrayList(Arrays.asList(blacklistPortalProfileNamesRemoveString.split(",")));

						blacklistPortalProfileNames.removeAll(blacklistPortalProfileNamesRemove);

						for (int i = 0; i < blacklistPortalProfileNames.size(); i++) {
							sb.append(blacklistPortalProfileNames.get(i));

							if ((i + 1) < blacklistPortalProfileNames.size()) {
								sb.append(",");
							}
						}

						project.setProperty("blacklist.portal.profile.names", sb.toString());
					]]>
				</beanshell>
			</then>
		</if>

		<echo append="true" file="portal-impl/src/portal-ext.properties">

module.framework.properties.blacklist.portal.profile.names=${blacklist.portal.profile.names}</echo>

		<get-testcase-property property.name="portal.version" />

		<propertyregex
			input="${portal.version}"
			property="portal.major.version"
			regexp="(\d+\.\d+)\.\d+"
			select="\1"
		/>

		<if>
			<equals arg1="${portal.major.version}" arg2="5.1" />
			<then>
				<prepare-portal-legacy-properties portal.major.version="5.1" />
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${portal.major.version}" arg2="5.1" />
				<equals arg1="${portal.major.version}" arg2="5.2" />
			</or>
			<then>
				<prepare-portal-legacy-properties portal.major.version="5.2" />
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${portal.major.version}" arg2="5.1" />
				<equals arg1="${portal.major.version}" arg2="5.2" />
				<equals arg1="${portal.major.version}" arg2="6.0" />
			</or>
			<then>
				<prepare-portal-legacy-properties portal.major.version="6.0" />
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${portal.major.version}" arg2="5.1" />
				<equals arg1="${portal.major.version}" arg2="5.2" />
				<equals arg1="${portal.major.version}" arg2="6.0" />
				<equals arg1="${portal.major.version}" arg2="6.1" />
			</or>
			<then>
				<prepare-portal-legacy-properties portal.major.version="6.1" />
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${portal.major.version}" arg2="5.1" />
				<equals arg1="${portal.major.version}" arg2="5.2" />
				<equals arg1="${portal.major.version}" arg2="6.0" />
				<equals arg1="${portal.major.version}" arg2="6.1" />
				<equals arg1="${portal.major.version}" arg2="6.2" />
			</or>
			<then>
				<prepare-portal-legacy-properties portal.major.version="6.2" />

				<echo append="true" file="portal-impl/src/portal-ext.properties">

upgrade.processes=${upgrade.processes.master}</echo>
			</then>
		</if>

		<if>
			<isset property="set.permission.algorithm.5" />
			<then>
				<replace file="portal-impl/src/portal-ext.properties" token="#permissions.user.check.algorithm=5" value="permissions.user.check.algorithm=5" />
				<replace file="portal-impl/src/portal-ext.properties" token="#permissions.view.dynamic.inheritance=false" value="permissions.view.dynamic.inheritance=false" />
			</then>
		</if>

		<if>
			<isset property="set.permission.algorithm.6" />
			<then>
				<replace file="portal-impl/src/portal-ext.properties" token="permissions.user.check.algorithm=5" value="" />
				<replace file="portal-impl/src/portal-ext.properties" token="permissions.view.dynamic.inheritance=false" value="" />
			</then>
		</if>

		<get-testcase-property property.name="setup.wizard.enabled" />

		<if>
			<equals arg1="${setup.wizard.enabled}" arg2="true" />
			<then>
				<replace file="portal-impl/src/portal-ext.properties" token="setup.wizard.enabled=false" value="" />

				<echo append="true" file="portal-impl/src/portal-ext.properties">

include-and-override=${liferay.home}/portal-setup-wizard.properties</echo>
			</then>
		</if>

		<if>
			<isset property="test.set.default.portal.properties" />
			<then>
				<echo file="portal-impl/src/portal-ext.properties">liferay.home=${liferay.home}</echo>
			</then>
		</if>

		<get-testcase-property property.name="test.smtp.server.enabled" />

		<if>
			<isset property="test.smtp.server.enabled" />
			<then>
				<echo append="true" file="portal-impl/src/portal-ext.properties">

mail.session.mail.smtp.port=25000</echo>
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${vm.vmdk.suffix}" arg2="websphere-6.1.0.27" />
				<equals arg1="${vm.vmdk.suffix}" arg2="websphere-7.0.0.7" />
				<equals arg1="${vm.vmdk.suffix}" arg2="websphere-8.0.0.0" />
			</or>
			<then>
				<replace
					file="portal-impl/src/portal-ext.properties"
					token="liferay.home=${liferay.home}"
					value="liferay.home=C:/WINDOWS/system32/config/systemprofile/liferay"
				/>

				<echo append="true" file="portal-impl/src/portal-ext.properties">

auto.deploy.dest.dir=C:/WINDOWS/system32/config/systemprofile/liferay/websphere-deploy</echo>
			</then>
		</if>

		<apply-portal-ext-properties />
	</target>

	<target name="prepare-portal-properties">
		<replace file="portal-impl/src/portal.properties">
			<replacefilter
				token="#upgrade.processes="
				value="upgrade.processes="
			/>
			<replacefilter
				token="#com.liferay.portal.upgrade.UpgradeProcess_"
				value="com.liferay.portal.upgrade.UpgradeProcess_"
			/>
			<replacefilter
				token="verify.frequency=0"
				value="verify.frequency=1"
			/>
		</replace>
	</target>

	<target name="prepare-portlet-ext-properties">
		<for list="${test.case.available.property.names}" param="test.case.available.property.name">
			<sequential>
				<if>
					<contains string="@{test.case.available.property.name}" substring="portlet.properties.com.liferay" />
					<then>
						<get-testcase-property property.name="@{test.case.available.property.name}" />

						<propertycopy from="@{test.case.available.property.name}" name="osgi.module.custom.properties" silent="true" />

						<if>
							<isset property="osgi.module.custom.properties" />
							<then>
								<propertyregex
									input="@{test.case.available.property.name}"
									override="true"
									property="osgi.module.name"
									regexp="portlet\.properties\.(.*)"
									select="\1"
								/>

								<pathconvert property="osgi.module.jar.file">
									<path>
										<fileset dir="${liferay.home}/osgi">
											<include name="**/${osgi.module.name}.jar" />
										</fileset>
									</path>
								</pathconvert>

								<echo file="${liferay.home}/tmp/portlet-ext.properties">${osgi.module.custom.properties}</echo>

								<jar destfile="${osgi.module.jar.file}" update="true">
									<fileset dir="${liferay.home}/tmp">
										<include name="portlet-ext.properties" />
									</fileset>
								</jar>

								<delete dir="${liferay.home}/tmp" />
							</then>
						</if>
					</then>
				</if>

				<var name="osgi.module.custom.properties" unset="true" />
				<var name="osgi.module.jar.file" unset="true" />
				<var name="osgi.module.name" unset="true" />
			</sequential>
		</for>
	</target>

	<target name="prepare-poshi-runner-properties">
		<echo append="true" file="${test.ext.properties.file}">
			component.names=${component.names}
			ignore.errors.file.name=${project.dir}/portal-web/test-ignorable-error-lines.xml
			output.dir.name=${selenium.output.dir.name}
			product.names=${product.names}
			project.dir=${project.dir}
			test.case.available.property.names=${test.case.available.property.names}
			test.console.log.file.name=${liferay.home}/logs/liferay.*.xml
			test.console.shut.down.file.name=${project.dir}/console-shut-down
			test.dependencies.dir.name=dependencies
			test.poshi.warnings.file.name=${project.dir}/poshi-warnings.xml
			test.retry.command.wait.time=${test.retry.command.wait.time}
		</echo>

		<propertycopy from="browser.firefox.bin.file[${browser.firefox.version}]" name="browser.firefox.bin.file" silent="true" />

		<if>
			<isset property="browser.firefox.bin.file" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					browser.firefox.bin.file=${browser.firefox.bin.file}
				</echo>
			</then>
		</if>

		<if>
			<isset property="print.java.process.on.fail" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					print.java.process.on.fail=${print.java.process.on.fail}
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.base.dir.name" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.base.dir.name=${test.base.dir.name}
				</echo>
			</then>
			<else>
				<echo append="true" file="${test.ext.properties.file}">
					test.base.dir.name=test/
				</echo>
			</else>
		</if>

		<if>
			<and>
				<isset property="test.batch.max.group.size" />
				<isset property="test.batch.property.query" />
			</and>
			<then>
				<if>
					<os family="windows" />
					<then>
						<antelope:stringutil property="test.batch.property.query" string="${test.batch.property.query}">
							<antelope:replace regex="&quot;" replacement="\\\\\&quot;" />
						</antelope:stringutil>
					</then>
				</if>

				<echo append="true" file="${test.ext.properties.file}">
					test.batch.property.query=${test.batch.property.query}
					test.batch.max.group.size=${test.batch.max.group.size}
					test.batch.max.subgroup.size=${test.batch.max.subgroup.size}
					test.batch.run.type=${test.batch.run.type}
				</echo>
			</then>
			<elseif>
				<and>
					<isset property="test.batch.max.group.size" />
					<isset property="test.batch.property.names" />
					<isset property="test.batch.property.values" />
				</and>
				<then>
					<echo append="true" file="${test.ext.properties.file}">
						test.batch.max.group.size=${test.batch.max.group.size}
						test.batch.max.subgroup.size=${test.batch.max.subgroup.size}
						test.batch.property.names=${test.batch.property.names}
						test.batch.property.values=${test.batch.property.values}
						test.batch.run.type=${test.batch.run.type}
					</echo>
				</then>
			</elseif>
		</if>

		<if>
			<isset property="test.build.fix.pack.zip.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.build.fix.pack.zip.url=${test.build.fix.pack.zip.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.build.fix.pack.zip.url.previous" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.build.fix.pack.zip.url.previous=${test.build.fix.pack.zip.url.previous}
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.case.required.property.names" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.case.required.property.names=${test.case.required.property.names}
				</echo>

				<for list="${test.case.required.property.names}" param="test.case.required.property.name">
					<sequential>
						<if>
							<isset property="test.case.available.property.values[@{test.case.required.property.name}]" />
							<then>
								<echo append="true" file="${test.ext.properties.file}">
									test.case.available.property.values[@{test.case.required.property.name}]=${test.case.available.property.values[@{test.case.required.property.name}]}
								</echo>
							</then>
						</if>
					</sequential>
				</for>
			</then>
		</if>

		<if>
			<isset property="test.class" />
			<then>
				<if>
					<contains string="${test.class}" substring="," />
					<then>
						<echo append="true" file="${test.ext.properties.file}">
							test.name=${test.class}
						</echo>
					</then>
					<else>
						<get-poshi-test-name />

						<echo append="true" file="${test.ext.properties.file}">
							test.name=${poshi.test.name}
						</echo>
					</else>
				</if>
			</then>
		</if>

		<if>
			<isset property="test.include.dir.names" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.include.dir.names=${test.include.dir.names}
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.pause.on.failure" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.pause.on.failure=${test.pause.on.failure}
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.run.environment" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.run.environment=${test.run.environment}
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.subrepo.dirs" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.subrepo.dirs=${test.subrepo.dirs}
				</echo>
			</then>
		</if>

		<if>
			<contains string="${test.class}" substring="," />
			<then>
				<propertyregex
					input="${test.class}"
					override="false"
					property="test.name.skip.portal.instance"
					regexp="(.*?),.*"
					replace="\1"
				/>

				<echo append="true" file="${test.ext.properties.file}">
					test.portal.instance=true
					test.name.skip.portal.instance=${test.name.skip.portal.instance}
				</echo>
			</then>
			<else>
				<echo append="true" file="${test.ext.properties.file}">
					test.portal.instance=${test.portal.instance}
				</echo>
			</else>
		</if>

		<var name="test.toggle.file.names" unset="true" />

		<pathconvert pathsep="," property="test.toggle.file.names">
			<fileset dir="${project.dir}">
				<include name="modules/*/*/poshi.toggle" />
				<include name="modules/*/*/*/poshi.toggle" />
				<include name="modules/*/*/*/*/poshi.toggle" />
				<include name="modules/*/*/*/*/*/poshi.toggle" />
				<include name="modules/*/*/*/*/*/*/poshi.toggle" />
				<include name="portal-web/poshi.toggle" />
			</fileset>
		</pathconvert>

		<antelope:stringutil property="test.toggle.file.names" string="${test.toggle.file.names}">
			<antelope:replace regex="\\" replacement="/" />
		</antelope:stringutil>

		<if>
			<isset property="test.base.dir.name" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.toggle.file.names=${test.toggle.file.names},${test.base.dir.name}/poshi.toggle
				</echo>
			</then>
			<else>
				<echo append="true" file="${test.ext.properties.file}">
					test.toggle.file.names=${test.toggle.file.names}
				</echo>
			</else>
		</if>
	</target>

	<target name="prepare-selenium">
		<if>
			<matches pattern="[0-9]+_[0-9]+" string="${test.class}" />
			<then>
				<get-test-class />
			</then>
		</if>

		<delete file="${test.ext.properties.file}" />

		<antcall target="prepare-poshi-runner-properties">
			<param name="test.class" value="${test.class}" />
		</antcall>

		<antcall target="prepare-selenium-app-server-properties" />
		<antcall target="prepare-selenium-browser" />
		<antcall target="prepare-selenium-database-properties" />
		<antcall target="prepare-selenium-email-properties" />
		<antcall target="prepare-selenium-facebook-properties" />
		<antcall target="prepare-selenium-google-properties" />
		<antcall target="prepare-selenium-openid-properties" />
		<antcall target="prepare-selenium-recaptcha-properties" />
		<antcall target="prepare-selenium-required-properties" />
		<antcall target="prepare-selenium-sharepoint-properties" />
		<antcall target="prepare-selenium-testcase-properties" />

		<if>
			<isset property="legacy.theme.ids" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					theme.ids=${legacy.theme.ids}
				</echo>
			</then>
		</if>

		<if>
			<isset property="liferay.portal.branch" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					liferay.portal.branch=${liferay.portal.branch}
				</echo>
			</then>
		</if>

		<if>
			<isset property="liferay.portal.bundle" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					liferay.portal.bundle=${liferay.portal.bundle}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.url=${marketplace.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="osb.lcs.portlet.host.name" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					osb.lcs.portlet.host.name=${osb.lcs.portlet.host.name}
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${tcat.enabled}" arg2="true" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					tcat.admin.repository=${app.server.tcat.admin.dir}/tcat_init/webapps/${lp.version.dtd}
					tcat.enabled=true
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${tear.down.before.test}" arg2="true" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					tear.down.before.test=true
				</echo>
			</then>
		</if>

		<if>
			<not>
				<isset property="test.assert.console.errors" />
			</not>
			<then>
				<get-testcase-property property.name="test.assert.console.errors" />
			</then>
		</if>

		<if>
			<or>
				<equals arg1="${test.assert.console.errors}" arg2="false" />
				<equals arg1="${test.assert.console.errors}" arg2="true" />
			</or>
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.assert.console.errors=${test.assert.console.errors}
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${test.assert.liferay.errors}" arg2="false" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.assert.liferay.errors=false
				</echo>
			</then>
		</if>

		<if>
			<isset property="test.base.dir.name" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.base.dir.name=${test.base.dir.name}
				</echo>
			</then>
			<else>
				<echo append="true" file="${test.ext.properties.file}">
					test.base.dir.name=${basedir.unix}/portal-web/test/functional/com/liferay/portalweb/
				</echo>
			</else>
		</if>

		<if>
			<equals arg1="${test.batch.run.type}" arg2="sequential" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.skip.tear.down=false
				</echo>
			</then>
			<elseif>
				<isset property="test.skip.tear.down" />
				<then>
					<echo append="true" file="${test.ext.properties.file}">
						test.skip.tear.down=${test.skip.tear.down}
					</echo>
				</then>
			</elseif>
		</if>

		<if>
			<contains string="${test.class}" substring="#" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					testing.class.method=true
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${test.save.screenshot}" arg2="true" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					save.screenshot=true
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${test.save.web.page}" arg2="true" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					save.web.page=true
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${test.selenium.implementation}" arg2="selenium" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					selenium.implementation=com.thoughtworks.selenium.Selenium
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-app-server-properties">
		<if>
			<isset property="app.server.type" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					app.server.type=${app.server.type}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-browser">
		<get-testcase-property property.name="browser.type" />

		<echo append="true" file="${test.ext.properties.file}">
			browser.type=${browser.type}
			browser.version=${browser.version}
		</echo>

		<if>
			<or>
				<equals arg1="${browser.type}" arg2="android" />
				<equals arg1="${browser.type}" arg2="androidchrome" />
				<equals arg1="${browser.type}" arg2="iossafari" />
			</or>
			<then>
				<stop-appium />

				<start-appium />

				<echo append="true" file="${test.ext.properties.file}">
					mobile.android.home=${mobile.android.home}
					mobile.browser=true
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="android" />
			<then>
				<antcall target="prepare-mobile-device" />
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="androidchrome" />
			<then>
				<exec executable="/bin/bash" os="${os.apple},${os.unix}" outputproperty="mobile.device.name">
					<arg value="-c" />
					<arg value="${mobile.android.home}/platform-tools/adb devices" />
				</exec>

				<propertyregex input="${mobile.device.name}" override="true" property="mobile.device.name" regexp=".*\n([A-z0-9]*)" select="\1" />

				<echo append="true" file="${test.ext.properties.file}">
					mobile.device.name=${mobile.device.name}
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="chrome" />
			<then>
				<prepare-chrome-driver />

				<echo append="true" file="${test.ext.properties.file}">
					selenium.chrome.driver.executable=${selenium.chrome.driver.executable}
					selenium.chrome.driver.version=${selenium.chrome.driver.version}
					selenium.executable.dir.name=${selenium.executable.dir.name}
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="edge" />
			<then>
				<prepare-edge-driver />

				<echo append="true" file="${test.ext.properties.file}">
					selenium.executable.dir.name=${selenium.executable.dir.name}
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="internetexplorer" />
			<then>
				<prepare-ie-driver />

				<echo append="true" file="${test.ext.properties.file}">
					selenium.executable.dir.name=${selenium.executable.dir.name}
					selenium.ie.driver.executable=${selenium.ie.driver.executable}
					selenium.ie.driver.version=${selenium.ie.driver.version}
				</echo>
			</then>
		</if>

		<if>
			<equals arg1="${browser.type}" arg2="safari" />
			<then>
				<prepare-safari-driver />
			</then>
		</if>

		<if>
			<equals arg1="${selenium.remote.driver.enabled}" arg2="true" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					selenium.desired.capabilities.platform=${selenium.desired.capabilities.platform}
					selenium.remote.driver.enabled=${selenium.remote.driver.enabled}
					selenium.remote.driver.hub=${selenium.remote.driver.hub}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-database-properties">
		<if>
			<isset property="database.db2.driver" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.db2.driver=${database.db2.driver}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.db2.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.db2.password=${database.db2.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.db2.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.db2.url=${database.db2.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.db2.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.db2.username=${database.db2.username}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.hypersonic.driver" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.hypersonic.driver=${database.hypersonic.driver}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.hypersonic.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.hypersonic.password=${database.hypersonic.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.hypersonic.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.hypersonic.url=${database.hypersonic.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.hypersonic.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.hypersonic.username=${database.hypersonic.username}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.mysql.driver" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.mysql.driver=${database.mysql.driver}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.mysql.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.mysql.password=${database.mysql.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.mysql.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.mysql.url=${database.mysql.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.mysql.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.mysql.username=${database.mysql.username}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.oracle.driver" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.oracle.driver=${database.oracle.driver}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.oracle.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.oracle.password=${database.oracle.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.oracle.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.oracle.url=${database.oracle.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.oracle.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.oracle.username=${database.oracle.username}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.postgresql.driver" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.postgresql.driver=${database.postgresql.driver}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.postgresql.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.postgresql.password=${database.postgresql.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.postgresql.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.postgresql.url=${database.postgresql.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.postgresql.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.postgresql.username=${database.postgresql.username}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.sybase.driver" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.sybase.driver=${database.sybase.driver}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.sybase.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.sybase.password=${database.sybase.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.sybase.url" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.sybase.url=${database.sybase.url}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.sybase.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.sybase.username=${database.sybase.username}
				</echo>
			</then>
		</if>

		<if>
			<isset property="database.type" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					database.type=${database.type}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-email-properties">
		<if>
			<isset property="email.address.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.address.1=${email.address.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.address.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.address.2=${email.address.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.address.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.address.3=${email.address.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.address.4" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.address.4=${email.address.4}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.address.5" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.address.5=${email.address.5}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.password.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.password.1=${email.password.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.password.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.password.2=${email.password.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.password.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.password.3=${email.password.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.password.4" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.password.4=${email.password.4}
				</echo>
			</then>
		</if>

		<if>
			<isset property="email.password.5" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					email.password.5=${email.password.5}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.address.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.address.1=${lcs.email.address.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.address.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.address.2=${lcs.email.address.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.address.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.address.3=${lcs.email.address.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.id.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.id.1=${lcs.email.id.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.id.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.id.2=${lcs.email.id.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.id.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.id.3=${lcs.email.id.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.password.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.password.1=${lcs.email.password.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.password.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.password.2=${lcs.email.password.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="lcs.email.password.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					lcs.email.password.3=${lcs.email.password.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.address.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.address.1=${marketplace.email.address.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.address.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.address.2=${marketplace.email.address.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.address.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.address.3=${marketplace.email.address.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.address.4" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.address.4=${marketplace.email.address.4}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.address.5" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.address.5=${marketplace.email.address.5}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.password.1" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.password.1=${marketplace.email.password.1}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.password.2" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.password.2=${marketplace.email.password.2}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.password.3" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.password.3=${marketplace.email.password.3}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.password.4" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.password.4=${marketplace.email.password.4}
				</echo>
			</then>
		</if>

		<if>
			<isset property="marketplace.email.password.5" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					marketplace.email.password.5=${marketplace.email.password.5}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-facebook-properties">
		<if>
			<isset property="facebook.application.id" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					facebook.application.id=${facebook.application.id}
				</echo>
			</then>
		</if>

		<if>
			<isset property="facebook.application.secret" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					facebook.application.secret=${facebook.application.secret}
				</echo>
			</then>
		</if>

		<if>
			<isset property="facebook.email" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					facebook.email=${facebook.email}
				</echo>
			</then>
		</if>

		<if>
			<isset property="facebook.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					facebook.password=${facebook.password}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-google-properties">
		<if>
			<isset property="google.api.key" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					google.api.key=${google.api.key}
				</echo>
			</then>
		</if>

		<if>
			<isset property="google.client.id" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					google.client.id=${google.client.id}
				</echo>
			</then>
		</if>

		<if>
			<isset property="google.client.secret" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					google.client.secret=${google.client.secret}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-openid-properties">
		<if>
			<isset property="openid.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					openid.password=${openid.password}
				</echo>
			</then>
		</if>

		<if>
			<isset property="openid.username" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					openid.username=${openid.username}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-recaptcha-properties">
		<if>
			<isset property="recaptcha.private.key" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					recaptcha.private.key=${recaptcha.private.key}
				</echo>
			</then>
		</if>

		<if>
			<isset property="recaptcha.public.key" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					recaptcha.public.key=${recaptcha.public.key}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-required-properties">
		<get-test-url />

		<echo append="true" file="${test.ext.properties.file}">
			portal.url=${test.url}
			selenium.executable.dir=${basedir.unix}/tools/selenium/
			selenium.logger.enabled=${test.selenium.logger.enabled}
			test.class.command.name=${test.class}
		</echo>
	</target>

	<target name="prepare-selenium-sharepoint-properties">
		<if>
			<isset property="sharepoint.oauth.authorization.grant.endpoint" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.authorization.grant.endpoint=${sharepoint.oauth.authorization.grant.endpoint}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.authorization.token.endpoint" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.authorization.token.endpoint=${sharepoint.oauth.authorization.token.endpoint}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.client.id" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.client.id=${sharepoint.oauth.client.id}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.client.secret" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.client.secret=${sharepoint.oauth.client.secret}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.configuration.name" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.configuration.name=${sharepoint.oauth.configuration.name}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.configuration.resource" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.configuration.resource=${sharepoint.oauth.configuration.resource}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.configuration.scope" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.configuration.scope=${sharepoint.oauth.configuration.scope}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.site.domain" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.site.domain=${sharepoint.oauth.site.domain}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.tenant.id" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.tenant.id=${sharepoint.oauth.tenant.id}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.user.name" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.user.name=${sharepoint.oauth.user.name}
				</echo>
			</then>
		</if>

		<if>
			<isset property="sharepoint.oauth.user.password" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					sharepoint.oauth.user.password=${sharepoint.oauth.user.password}
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-selenium-testcase-properties">
		<get-testcase-property property.name="cmis.repository.type" />

		<if>
			<or>
				<equals arg1="${cmis.repository.type}" arg2="documentum6" />
				<equals arg1="${cmis.repository.type}" arg2="sharepoint2010" />
				<equals arg1="${cmis.repository.type}" arg2="sharepoint2013" />
			</or>
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					cmis.repository.vm.host.name=${cmis.repository.vm.host.name}
				</echo>
			</then>
		</if>

		<get-testcase-property property.name="ignore.errors" />

		<if>
			<isset property="ignore.errors" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					ignore.errors=${ignore.errors}
				</echo>
			</then>
		</if>

		<get-testcase-property property.name="ignore.errors.delimiter" />

		<if>
			<isset property="ignore.errors.delimiter" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					ignore.errors.delimiter=${ignore.errors.delimiter}
				</echo>
			</then>
		</if>

		<get-testcase-property property.name="test.assert.javascript.errors" />

		<if>
			<equals arg1="${test.assert.javascript.errors}" arg2="false" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.assert.javascript.errors=false
				</echo>
			</then>
		</if>

		<get-testcase-property property.name="test.assert.warning.exceptions" />

		<if>
			<isset property="test.assert.warning.exceptions" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.assert.warning.exceptions=${test.assert.warning.exceptions}
				</echo>
			</then>
		</if>

		<get-testcase-property property.name="test.name.skip.portal.instance" />

		<if>
			<isset property="test.name.skip.portal.instance" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					test.name.skip.portal.instance=${test.name.skip.portal.instance}
				</echo>
			</then>
		</if>

		<get-testcase-property property.name="theme.file.name" />

		<if>
			<isset property="theme.file.name" />
			<then>
				<if>
					<resourcecount count="0" when="greater">
						<zipfileset src="${liferay.home}/osgi/war/${theme.file.name}">
							<patternset>
								<include name="**/private.lar" />
							</patternset>
						</zipfileset>
					</resourcecount>
					<then>
						<echo append="true" file="${test.ext.properties.file}">
							theme.contains.resources=true
						</echo>
					</then>
				</if>
			</then>
		</if>

		<property name="default.timeout.explicit.wait" value="${timeout.explicit.wait}" />

		<get-testcase-property property.name="timeout.explicit.wait" />

		<if>
			<isset property="timeout.explicit.wait" />
			<then>
				<echo append="true" file="${test.ext.properties.file}">
					timeout.explicit.wait=${timeout.explicit.wait}
				</echo>
			</then>
			<else>
				<echo append="true" file="${test.ext.properties.file}">
					timeout.explicit.wait=${default.timeout.explicit.wait}
				</echo>
			</else>
		</if>
	</target>

	<target name="prepare-so-plugins">
		<set-tomcat-version-number liferay.portal.bundle="${liferay.portal.bundle}" />

		<property file="${lp.plugins.dir}/portlets/so-portlet/docroot/WEB-INF/liferay-releng.properties" />

		<property name="plugins.includes" value="so-portlet,${dependent-apps}" />

		<ant antfile="build-test-plugins.xml" target="deploy-simple-server-plugins" />
	</target>

	<target name="prepare-system-ext-properties">
		<echo file="${app.server.classes.portal.dir}/system-ext.properties">liferay.mode=test
log.sanitizer.enabled=false</echo>

	</target>

	<target name="prepare-test-build">
		<record-git-commit-portal />

		<antcall inheritAll="false" target="compile" />

		<prepare-test-bundles unit="false" />

		<if>
			<not>
				<equals arg1="${test.build.unit}" arg2="true" />
			</not>
			<then>
				<antcall target="record-test-case-method-names" />
			</then>
		</if>

		<antcall inheritAll="false" target="compile-test" />

		<record-test-class-file-names />

		<antcall inheritAll="false" target="record-test-plugin-names" />

		<echo if:set="env.JENKINS_HOME">
ANT_OPTS=${env.ANT_OPTS}</echo>

		<antcall if:set="env.JENKINS_HOME" target="clean-up-db2-processes" inheritAll="false" />
		<antcall if:set="env.JENKINS_HOME" target="clean-up-java-processes" inheritAll="false" />
	</target>

	<target name="prepare-test-build-custom">
		<app-server-properties-update>
			app.server.type=${app.server.type}
		</app-server-properties-update>

		<antcall inheritAll="false" target="update-sdk-properties" />

		<ant antfile="build-dist.xml" inheritAll="false" target="unzip-${app.server.type}-custom" />

		<if>
			<equals arg1="${app.server.type}" arg2="weblogic" />
			<then>
				<replaceregexp
					file="${app.server.weblogic.bin.dir}/stopWebLogic.sh"
					flags="g"
					match="(t3:\/\/)[^\:]*(\:\d+)"
					replace="\1${env.HOSTNAME}\2"
				/>

				<chmod perm="a+x">
					<fileset dir="${app.server.weblogic.bin.dir}">
						<include name="**/*.sh" />
					</fileset>
				</chmod>

				<chmod perm="a+x">
					<fileset dir="${app.server.weblogic.instance.dir}">
						<include name="**/*.sh" />
					</fileset>
				</chmod>
			</then>
			<elseif>
				<equals arg1="${app.server.type}" arg2="websphere" />
				<then>
					<replace
						dir="${app.server.websphere.dir}"
						includes="**/*.js,**/*.metadata,**/*.properties,**/*.props,**/*.sh,**/*.txt,**/*.xml"
					>
						<replacefilter token="/opt/dev/projects/github/liferay-portal/bundles" value="${app.server.parent.dir}" />
					</replace>

					<replace
						dir="${app.server.websphere.dir}"
						includes="**/*.sh"
					>
						<replacefilter token="#!/bin/sh" value="#!/bin/bash" />
					</replace>

					<chmod perm="a+x">
						<fileset dir="${app.server.websphere.bin.dir}">
							<include name="**/*.sh" />
						</fileset>
					</chmod>

					<chmod perm="a+x">
						<fileset dir="${app.server.websphere.dir}">
							<include name="bin/**/*.sh" />
							<include name="java*/bin/*" />
						</fileset>
					</chmod>
				</then>
			</elseif>
		</if>

		<ant inheritAll="false" target="deploy" />

		<app-server-properties-reset />
	</target>

	<target name="prepare-test-build-tomcat-dependents">
		<if>
			<equals arg1="${test.build.bundle.tcat}" arg2="true" />
			<then>
				<echo file="${lp.plugins.dir}/build.${user.name}.properties">app.server.tomcat.dir=${app.server.parent.dir}/tomcat-7.0.39

liferay.home=${liferay.home}

plugins.includes=marketplace-portlet</echo>

				<if>
					<matches pattern="https?://" string="${test.build.portal.war.url}" />
					<then>
						<mkdir dir="dist" />

						<mirrors-get
							dest="dist/liferay-portal-${lp.version}.war"
							src="${test.build.portal.war.url}"
						/>
					</then>
					<else>
						<ant antfile="build-dist.xml" inheritAll="false" target="zip-portal-war" />
					</else>
				</if>

				<ant antfile="build-dist.xml" inheritAll="false" target="build-dist-tcat" />

				<delete dir="dist" />

				<delete file="${lp.plugins.dir}/build.${user.name}.properties" />
			</then>
		</if>
	</target>

	<target name="prepare-test-build-unit">
		<record-git-commit-portal />

		<antcall inheritAll="false" target="compile" />

		<prepare-test-bundles unit="true" />

		<antcall inheritAll="false" target="compile-test" />

		<record-test-class-file-names />

		<echo if:set="env.JENKINS_HOME">
ANT_OPTS=${env.ANT_OPTS}</echo>

		<antcall if:set="env.JENKINS_HOME" target="clean-up-db2-processes" inheritAll="false" />
		<antcall if:set="env.JENKINS_HOME" target="clean-up-java-processes" inheritAll="false" />
	</target>

	<target name="prepare-test-bundle">
		<setup-libs />

		<if>
			<not>
				<isset property="app.server.name" />
			</not>
			<then>
				<property name="app.server.name" value="${app.server.type}" />
			</then>
		</if>

		<if>
			<matches pattern="https?://" string="${test.build.bundle.zip.url}" />
			<then>
				<mkdir dir="${app.server.parent.dir}" />

				<tstamp>
					<format pattern="yyyyMMddkkmmssSSS" property="tstamp.value" />
				</tstamp>

				<mirrors-get
					dest="${tstamp.value}.zip"
					src="${test.build.bundle.zip.url}"
				/>

				<unzip dest="${app.server.parent.dir}" src="${tstamp.value}.zip">
					<patternset includes="liferay-*/**" />
					<mapper from="[^/]+/(.*)" to="\1" type="regexp" />
				</unzip>

				<delete file="${tstamp.value}.zip" />

				<chmod perm="a+x">
					<fileset dir="${test.app.server.bin.dir}">
						<include name="*.sh" />
					</fileset>
				</chmod>
			</then>
			<else>
				<if>
					<and>
						<equals arg1="${app.server.jboss.version}" arg2="6.1.0" />
						<equals arg1="${app.server.type}" arg2="jboss" />
					</and>
					<then>
						<ant antfile="build-dist.xml" inheritAll="false" target="unzip-jboss" />
					</then>
					<elseif>
						<equals arg1="${app.server.type}" arg2="tcserver" />
						<then>
							<ant antfile="build-dist.xml" inheritAll="false" target="unzip-tcserver" />
						</then>
					</elseif>
					<elseif>
						<equals arg1="${app.server.type}" arg2="weblogic" />
						<then>
							<ant antfile="build-dist.xml" inheritAll="false" target="unzip-weblogic-custom" />

							<chmod perm="a+x">
								<fileset dir="${app.server.weblogic.bin.dir}">
									<include name="**/*.sh" />
								</fileset>
							</chmod>

							<chmod perm="a+x">
								<fileset dir="${app.server.weblogic.instance.dir}">
									<include name="**/*.sh" />
								</fileset>
							</chmod>
						</then>
					</elseif>
				</if>

				<mkdir dir="dist" />

				<mirrors-get
					dest="dist/liferay-portal-${lp.version}.war"
					src="${test.build.portal.war.url}"
				/>

				<unzip
					dest="${app.server.portal.dir}"
					src="dist/liferay-portal-${lp.version}.war"
				/>

				<delete dir="dist" />

				<ant antfile="build.xml" inheritAll="false" target="update-app-server-scripts" />

				<mirrors-get
					dest="liferay-portal-dependencies.zip"
					src="${test.build.portal.dependencies.zip.url}"
				/>

				<unzip
					dest="${app.server.lib.global.dir}"
					src="liferay-portal-dependencies.zip"
				>
					<mapper
						from="[^/]+/(.*)"
						to="\1"
						type="regexp"
					/>
				</unzip>

				<delete file="liferay-portal-dependencies.zip" />

				<mirrors-get
					dest="liferay-portal-osgi.zip"
					src="${test.build.portal.osgi.zip.url}"
				/>

				<unzip
					dest="${liferay.home}/osgi"
					src="liferay-portal-osgi.zip"
				>
					<mapper
						from="[^/]+/(osgi/)?(.*)"
						to="\2"
						type="regexp"
					/>
				</unzip>

				<delete file="liferay-portal-osgi.zip" />
			</else>
		</if>

		<if>
			<matches pattern="https?://" string="${test.build.fix.pack.zip.url}" />
			<then>
				<antcall target="prepare-patching-tool" />

				<get-testcase-property property.name="skip.install-patch" />

				<if>
					<not>
						<equals arg1="${skip.install-patch}" arg2="true" />
					</not>
					<then>
						<antcall target="install-patch">
							<param name="patch.file.zip.url" value="${test.build.fix.pack.zip.url}" />
						</antcall>
					</then>
				</if>
			</then>
		</if>

		<if>
			<equals arg1="${app.server.type}" arg2="tomcat" />
			<then>
				<antcall target="prepare-tomcat-ext-environment" />
			</then>
		</if>
	</target>

	<target name="prepare-tomcat-ext-environment">
		<if>
			<and>
				<matches pattern="https?://" string="${test.build.bundle.zip.url}" />
				<matches pattern="https?://" string="${test.build.fix.pack.zip.url}" />
				<not>
					<resourcecontains resource="${app.server.dir}/conf/Catalina/localhost/ROOT.xml" substring="ExtResourceSet" />
				</not>
			</and>
			<then>
				<local name="enable.ext.environment" />

				<get-fixpack-version patch.file.zip.url="${test.build.fix.pack.zip.url}" />

				<beanshell>
					<![CDATA[
						String fixpackVersion = project.getProperty("fixpack.version");

						if (fixpackVersion != null) {
							int fixpackVersionInt = Integer.valueOf(fixpackVersion);

							if (fixpackVersionInt >= 16) {
								project.setProperty("enable.ext.environment", "true");
							}
						}
					]]>
				</beanshell>

				<if>
					<equals arg1="${enable.ext.environment}" arg2="true" />
					<then>
						<replace file="${app.server.dir}/conf/Catalina/localhost/ROOT.xml">
							<replacetoken><![CDATA[</Context>]]></replacetoken>
							<replacevalue><![CDATA[	<Resources>
		<PreResources
			base="${catalina.base}/lib/ext/portal"
			className="com.liferay.support.tomcat.webresources.ExtResourceSet"
			webAppMount="/WEB-INF/lib"
		/>
	</Resources>
</Context>]]></replacevalue>
						</replace>
					</then>
				</if>
			</then>
		</if>
	</target>

	<target name="prepare-virtual-host-name-properties">
		<if>
			<isset property="virtual.host.name" />
			<then>
				<echo append="true" file="portal-web/test/test-portal-impl-ext.properties">
					portal.url=www.${virtual.host.name}.com:8080
				</echo>

				<echo append="true" file="${test.ext.properties.file}">
					portal.url=www.${virtual.host.name}.com:8080
				</echo>
			</then>
		</if>
	</target>

	<target name="prepare-virtual-network-interface">
		<echo append="true" file="portal-impl/src/portal-ext.properties">

cluster.link.channel.system.properties=\
	#
	# Common
	#
	\
	jgroups.bind_addr:${cluster.link.bind.addr["cluster-link-udp"]},\
	jgroups.bind_interface:eth0:0,\
	\
	#
	# Multicast
	#
	\
	jgroups.mping.mcast_addr:${multicast.group.address["cluster-link-mping"]},\
	jgroups.mping.mcast_port:${multicast.group.port["cluster-link-mping"]},\
	jgroups.mping.ip_ttl:8

cluster.link.autodetect.address=

cluster.link.bind.addr["cluster-link-control"]=127.0.0.1

cluster.link.bind.addr["cluster-link-udp"]=127.0.0.1</echo>
	</target>

	<target name="print-scm-revision">
		<echo>Portal GIT ID:</echo>
		<echo />

		<exec dir="${project.dir}" executable="git">
			<arg line="log -n 1" />
		</exec>

		<echo />
		<echo>Plugins GIT ID:</echo>
		<echo />

		<exec dir="${lp.plugins.dir}" executable="git">
			<arg line="log -n 1" />
		</exec>

		<echo />
	</target>

	<target depends="build-sql-file" name="rebuild-database">
		<if>
			<not>
				<isset property="skip.rebuild-database" />
			</not>
			<then>
				<get-testcase-property property.name="portal.version" />

				<if>
					<not>
						<isset property="portal.version" />
					</not>
					<then>
						<antcall target="delete-liferay-home" />
					</then>
				</if>

				<if>
					<equals arg1="${database.type}" arg2="db2" />
					<then>
						<if>
							<os family="windows" />
							<then>
								<exec executable="${db2.executable}">
									<arg line="/c /w db2 disconnect lportal" />
								</exec>

								<exec executable="${db2.executable}">
									<arg line="/c /w db2 drop db lportal" />
								</exec>

								<exec executable="${db2.executable}">
									<arg line="/c /w db2 -fcreate.sql -td;" />
								</exec>
							</then>
							<else>
								<exec executable="${db2.executable}">
									<arg line="disconnect lportal" />
								</exec>

								<exec executable="${db2.executable}">
									<arg line="drop db lportal" />
								</exec>

								<exec executable="${db2.executable}" failonerror="true">
									<arg value="-fcreate.sql" />
									<arg value="-t" />
								</exec>
							</else>
						</if>
					</then>
					<elseif>
						<equals arg1="${database.type}" arg2="hypersonic" />
						<then>
							<delete dir="${liferay.home}/data" includeemptydirs="true" />

							<copy file="sql/${database.name}.properties" tofile="${liferay.home}/data/hypersonic/${database.name}.properties" />
							<copy file="sql/${database.name}.script" tofile="${liferay.home}/data/hypersonic/${database.name}.script" />
						</then>
					</elseif>
					<elseif>
						<or>
							<equals arg1="${database.type}" arg2="mariadb" />
							<equals arg1="${database.type}" arg2="mysql" />
						</or>
						<then>
							<var name="arg.line" unset="true" />

							<get-database-property property.name="database.password" />
							<get-database-property property.name="database.username" />

							<if>
								<and>
									<equals arg1="${database.password}" arg2="" />
									<equals arg1="${database.username}" arg2="" />
								</and>
								<then>
									<var name="arg.line" value="" />
								</then>
								<elseif>
									<equals arg1="${database.password}" arg2="" />
									<then>
										<var name="arg.line" value="-u ${database.username}" />
									</then>
								</elseif>
								<elseif>
									<equals arg1="${database.username}" arg2="" />
									<then>
										<var name="arg.line" value="-p${database.password}" />
									</then>
								</elseif>
								<else>
									<var name="arg.line" value="-p${database.password} -u ${database.username}" />
								</else>
							</if>

							<propertycopy from="${database.type}.executable" name="database.executable" override="true" />

							<exec executable="${database.executable}" failonerror="true" input="create.sql">
								<arg line="${arg.line}" />
							</exec>
						</then>
					</elseif>
					<elseif>
						<equals arg1="${database.type}" arg2="oracle" />
						<then>
							<get-database-property property.name="database.password" />
							<get-database-property property.name="database.username" />

							<exec executable="su" failonerror="true">
								<arg value="-c" />
								<arg value="${oracle.sqlplus.executable} ${oracle.admin.user}/${oracle.admin.password} as sysdba @create.sql ${database.username} ${database.password}" />
								<arg value="oracle" />
							</exec>
						</then>
					</elseif>
					<elseif>
						<equals arg1="${database.type}" arg2="postgresql" />
						<then>
							<get-database-property property.name="database.username" />

							<exec executable="${postgresql.executable}" failonerror="true">
								<arg value="-f" />
								<arg value="create.sql" />
								<arg value="-U" />
								<arg value="${database.username}" />
							</exec>
						</then>
					</elseif>
					<elseif>
						<equals arg1="${database.type}" arg2="sqlserver" />
						<then>
							<get-database-property property.name="database.password" />
							<get-database-property property.name="database.username" />

							<exec executable="${sqlserver.executable}" failonerror="true">
								<arg value="-U" />
								<arg value="${database.username}" />
								<arg value="-P" />
								<arg value="${database.password}" />
								<arg value="-i" />
								<arg value="create.sql" />
							</exec>
						</then>
					</elseif>
					<elseif>
						<equals arg1="${database.type}" arg2="sybase" />
						<then>
							<get-database-property property.name="database.password" />
							<get-database-property property.name="database.schema" />
							<get-database-property property.name="database.username" />

							<echo>${sybase.executable} -i create.sql -P ${database.password} -S ${database.schema} -U ${database.username}</echo>

							<exec executable="${sybase.executable}" failonerror="true">
								<arg value="-i" />
								<arg value="create.sql" />
								<arg value="-P" />
								<arg value="${database.password}" />
								<arg value="-S" />
								<arg value="${database.schema}" />
								<arg value="-U" />
								<arg value="${database.username}" />
							</exec>
						</then>
					</elseif>
				</if>
			</then>
		</if>

		<delete file="create.sql" />
	</target>

	<target name="rebuild-legacy-database">
		<get-testcase-property property.name="data.archive.type" />
		<get-testcase-property property.name="portal.version" />

		<unzip
			dest="${liferay.home}"
			src="${portal.legacy.dir}/${portal.version}/data-archive/${data.archive.type}-${database.type}.zip"
		/>

		<if>
			<equals arg1="${database.type}" arg2="db2" />
			<then>
				<echo>chmod -v 777 ${liferay.home}</echo>

				<chmod file="${liferay.home}" perm="777" type="dir" verbose="true" />

				<echo>${db2.executable} restore database lportal from ${liferay.home} replace existing</echo>

				<exec executable="${db2.executable}" outputproperty="db2.executable.output">
					<arg line="restore database lportal from ${liferay.home} replace existing" />
				</exec>

				<echo>${db2.executable.output}</echo>
			</then>
			<elseif>
				<equals arg1="${database.type}" arg2="mariadb" />
				<then>
					<antcall target="rebuild-database">
						<param name="database.type" value="${database.type}" />
						<param name="sql.dir" value="sql/create-bare/" />
						<param name="sql.file" value="create-bare-mysql.sql" />
					</antcall>

					<get-database-property property.name="database.password" />
					<get-database-property property.name="database.schema" />
					<get-database-property property.name="database.username" />

					<exec executable="${mariadb.executable}" input="${liferay.home}/${database.type}.sql">
						<arg value="--database=${database.schema}" />
						<arg value="--password=${database.password}" />
						<arg value="--user=${database.username}" />
					</exec>
				</then>
			</elseif>
			<elseif>
				<equals arg1="${database.type}" arg2="mysql" />
				<then>
					<antcall target="rebuild-database">
						<param name="database.type" value="${database.type}" />
						<param name="sql.dir" value="sql/create-bare/" />
						<param name="sql.file" value="create-bare-mysql.sql" />
					</antcall>

					<get-database-property property.name="database.password" />
					<get-database-property property.name="database.schema" />
					<get-database-property property.name="database.username" />

					<exec executable="${mysql.executable}" input="${liferay.home}/${database.type}.sql">
						<arg value="--database=${database.schema}" />
						<arg value="--password=${database.password}" />
						<arg value="--user=${database.username}" />
					</exec>

					<exec executable="mysql_upgrade" />
				</then>
			</elseif>
			<elseif>
				<equals arg1="${database.type}" arg2="oracle" />
				<then>
					<sql classpath="${app.server.lib.global.dir}/${jdbc.oracle.driver}" driver="oracle.jdbc.OracleDriver" onerror="continue" output="data.pump.log" password="${oracle.admin.password}" print="true" url="${database.oracle.url}" userid="${oracle.admin.user}">
						<![CDATA[
							drop user lportal cascade;
							select directory_name, directory_path from dba_directories where directory_name='DATA_PUMP_DIR';
						]]>
					</sql>

					<loadfile property="data.pump.log.content" srcFile="data.pump.log" />

					<propertyregex
						input="${data.pump.log.content}"
						override="true"
						property="data.pump.dir"
						regexp="[\s\S]+DATA_PUMP_DIR,(.*)[\s\S]+"
						replace="\1"
					/>

					<move file="${liferay.home}/${database.type}.dmp" todir="${data.pump.dir}" />

					<chown file="${data.pump.dir}/${database.type}.dmp" owner="oracle" />
					<chgrp file="${data.pump.dir}/${database.type}.dmp" group="oracle" />

					<exec executable="impdp">
						<arg value="${oracle.admin.user}/${oracle.admin.password}" />
						<arg value="dumpfile=${database.type}.dmp" />
						<arg value="table_exists_action=replace" />
					</exec>

					<delete file="${data.pump.dir}/${database.type}.dmp" />
				</then>
			</elseif>
			<elseif>
				<equals arg1="${database.type}" arg2="postgresql" />
				<then>
					<antcall target="rebuild-database">
						<param name="database.type" value="${database.type}" />
						<param name="sql.dir" value="sql/create-bare/" />
						<param name="sql.file" value="create-bare-${database.type}.sql" />
					</antcall>

					<get-database-property property.name="database.schema" />
					<get-database-property property.name="database.username" />

					<exec executable="${postgresql.executable}" failonerror="true">
						<arg value="--dbname=${database.schema}" />
						<arg value="--file=${liferay.home}/${database.type}.sql" />
						<arg value="--username=${database.username}" />
					</exec>
				</then>
			</elseif>
			<elseif>
				<equals arg1="${database.type}" arg2="sybase" />
				<then>
					<echo file="import-sybase.sql">load database lportal from "${liferay.home}/${database.type}.dmp"
go
online database lportal
go</echo>

					<exec executable="${env.SYBASE}/${env.SYBASE_ASE}/bin/backupserver" spawn="true">
						<arg value="-Slportal_BS" />
					</exec>

					<waitfor maxwait="60" maxwaitunit="second">
						<socket port="5001" server="localhost" />
					</waitfor>

					<print-file file.name="import-sybase.sql" />

					<print-file file.name="lportal__srv.log" />

					<local name="output.content" />

					<exec executable="${sybase.executable}" logError="true" outputproperty="output.content">
						<arg value="-i" />
						<arg value="import-sybase.sql" />
						<arg value="-P" />
						<arg value="${database.sybase.password}" />
						<arg value="--retserverror" />
						<arg value="-S" />
						<arg value="${database.sybase.schema}" />
						<arg value="-U" />
						<arg value="${database.sybase.username}" />
					</exec>

					<echo>${output.content}</echo>

					<delete file="import-sybase.sql" />
					<delete file="lportal__srv.log" />

					<echo file="get-charset.sql">sp_helpsort
go</echo>

					<print-file file.name="get-charset.sql" />

					<exec executable="${sybase.executable}">
						<arg value="-P${database.sybase.password}" />
						<arg value="-S${database.sybase.schema}" />
						<arg value="-U${database.sybase.username}" />
						<arg line="-i get-charset.sql" />
					</exec>

					<delete file="get-charset.sql" />
				</then>
			</elseif>
		</if>
	</target>

	<target name="record-database-type">
		<echo append="true" file="database-type">${database.type},</echo>
	</target>

	<target name="record-git-commit-bottom-test-jsp">
		<exec dir="${project.dir}" executable="git" outputproperty="git.commit.portal.rev.parse">
			<arg line="rev-parse HEAD" />
		</exec>

		<exec dir="${project.dir}" executable="git" outputproperty="git.commit.portal.current.date">
			<arg line="log -1 --pretty=format:%cd HEAD" />
		</exec>

		<loadfile property="copyright.content" srcFile="${project.dir}/copyright.txt" />

		<if>
			<available file="${project.dir}/git-commit-portal" />
			<then>
				<loadfile property="git.commit.portal.base.branch" srcFile="${project.dir}/git-commit-portal" />

				<antelope:stringutil property="git.commit.portal.base.branch" string="${git.commit.portal.base.branch}">
					<antelope:trim />
				</antelope:stringutil>

				<property name="git.commit.information" value="Commit: &lt;a href=&quot;https://github.com/liferay/liferay-portal/commit/${git.commit.portal.rev.parse}&quot; target=&quot;_blank&quot;&gt;${git.commit.portal.rev.parse}&lt;/a&gt;&lt;br /&gt;Base Branch Commit: &lt;a href=&quot;https://github.com/liferay/liferay-portal/commit/${git.commit.portal.base.branch}&quot; target=&quot;_blank&quot;&gt;${git.commit.portal.base.branch}&lt;/a&gt;&lt;br /&gt;Updated on: ${git.commit.portal.current.date}" />
			</then>
			<else>
				<property name="git.commit.information" value="Commit: &lt;a href=&quot;https://github.com/liferay/liferay-portal/commit/${git.commit.portal.rev.parse}&quot; target=&quot;_blank&quot;&gt;${git.commit.portal.rev.parse}&lt;/a&gt;&lt;br /&gt;Updated on: ${git.commit.portal.current.date}" />
			</else>
		</if>

		<echo file="${app.server.dir}/webapps/ROOT/html/common/themes/bottom-test.jsp"><![CDATA[<%--
${copyright.content}
--%>

<%@ page import="com.liferay.portal.kernel.util.ParamUtil" %>

<%
String ppstate = ParamUtil.getString(request, "p_p_state", "normal");

if (ppstate.equals("normal")) {
%>

	<div class="alert alert-info" id="currentHead" style="margin: 2em">
		${git.commit.information}
	</div>

<%
}
%>]]></echo>

		<echo>Updated ${app.server.dir}/webapps/ROOT/html/common/themes/bottom-test.jsp.</echo>
	</target>

	<target name="record-git-commit-plugins">
		<record-git-commit-plugins />
	</target>

	<target name="record-git-commit-portal">
		<record-git-commit-portal />
	</target>

	<target name="record-test-case-method-names">
		<setup-libs />

		<delete failonerror="false" file="${test.ext.properties.file}" />

		<if>
			<isset property="test.base.dir.name" />
			<then>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties">
					<param name="test.base.dir.name" value="${test.base.dir.name}" />
					<param name="test.batch.run.type" value="${test.batch.run.type}" />
					<param name="test.portal.instance" value="${test.portal.instance}" />
				</antcall>
			</then>
			<else>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties">
					<param name="test.batch.run.type" value="${test.batch.run.type}" />
					<param name="test.portal.instance" value="${test.portal.instance}" />
				</antcall>
			</else>
		</if>

		<poshi-execute task="writePoshiProperties" />

		<move file="portal-web/test.case.method.names.properties" tofile="test.case.method.names.properties" />

		<echo></echo>
		<echo>##</echo>
		<echo>## test.case.method.names.properties</echo>
		<echo>##</echo>
		<echo></echo>

		<var name="file.content" unset="true" />

		<loadfile property="file.content" srcFile="test.case.method.names.properties" />

		<if>
			<contains string="${file.content}" substring="RUN_TEST_CASE_METHOD_GROUP" />
			<then>
				<beanshell>
					<![CDATA[
						import java.util.regex.Matcher;
						import java.util.regex.Pattern;

						Pattern pattern = Pattern.compile("RUN_TEST_CASE_METHOD_GROUP.*");

						Matcher matcher = pattern.matcher(project.getProperty("file.content"));

						sb = new StringBuilder();

						while (matcher.find()) {
							sb.append(matcher.group());
							sb.append("\n");
						}

						project.setProperty("file.content", sb.toString());
					]]>
				</beanshell>

				<echo></echo>
				<echo>${file.content}</echo>
				<echo></echo>
			</then>
			<else>
				<echo></echo>
				<echo>${file.content}</echo>
				<echo></echo>
			</else>
		</if>

		<var name="file.content" unset="true" />
	</target>

	<target name="record-test-class-file-names">
		<record-test-class-file-names />
	</target>

	<target name="record-test-generated-properties">
		<setup-libs />

		<delete failonerror="false" file="${test.ext.properties.file}" />

		<if>
			<isset property="test.base.dir.name" />
			<then>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties">
					<param name="test.base.dir.name" value="${test.base.dir.name}" />
					<param name="test.class" value="${test.class}" />
				</antcall>
			</then>
			<else>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties" />
			</else>
		</if>

		<poshi-execute task="writePoshiProperties" />

		<move file="portal-web/test.generated.properties" tofile="test.generated.properties" />

		<if>
			<isset property="test.class" />
			<then>
				<loadfile failonerror="false" property="test.generated.properties.content" srcfile="test.generated.properties" />

				<get-poshi-class-name />

				<if>
					<contains string="${test.class}" substring="#" />
					<then>
						<get-poshi-method-name />
					</then>
				</if>

				<beanshell>
					<![CDATA[
						import java.util.regex.Matcher;
						import java.util.regex.Pattern;

						StringBuilder sb = new StringBuilder();

						sb.append("(");
						sb.append(project.getProperty("poshi.class.name"));
						sb.append("TestCase\\.(test");

						String poshiMethodName = project.getProperty("poshi.method.name");

						if (poshiMethodName != null) {
							sb.append(poshiMethodName);
							sb.append("\\.|");
						}
						else {
							sb.append("[^\\.]*\\.|");
						}

						sb.append("all\\.).*)\\\n");

						Pattern pattern = Pattern.compile(sb.toString());

						Matcher matcher = pattern.matcher(project.getProperty("test.generated.properties.content"));

						sb = new StringBuilder();

						while (matcher.find()) {
							sb.append(matcher.group());
						}

						project.setProperty("test.generated.properties.content", sb.toString());
					]]>
				</beanshell>

				<echo>##</echo>
				<echo>## test.generated.properties</echo>
				<echo>##</echo>
				<echo></echo>
				<echo>${test.generated.properties.content}</echo>
				<echo></echo>
			</then>
		</if>
	</target>

	<target name="record-test-plugin-names">
		<loadproperties srcFile="${lp.plugins.dir}/build.properties">
			<filterchain>
				<linecontains>
					<contains value="plugins.excludes" />
				</linecontains>
			</filterchain>
		</loadproperties>

		<beanshell>
			<![CDATA[
				import org.apache.tools.ant.DirectoryScanner;

				List getPluginGroups(List pluginNames, int groupsSize) {
					List pluginNameGroups = new ArrayList(groupsSize);

					for (int i = 0; i < groupsSize; i++) {
						pluginNameGroups.add(new ArrayList());
					}

					int i = 0;

					for (String pluginName : pluginNames) {
						List pluginNameGroup = pluginNameGroups.get(i++ % groupsSize);

						pluginNameGroup.add(pluginName);
					}

					return pluginNameGroups;
				}

				List getPluginNames() {
					DirectoryScanner directoryScanner = new DirectoryScanner();

					directoryScanner.setBasedir(project.getProperty("lp.plugins.dir"));
					directoryScanner.setIncludes(new String[] {"**/hooks/*/build.xml", "**/layoutpl/*/build.xml", "**/portlets/*/build.xml", "**/shared/*/build.xml", "**/themes/*/build.xml", "**/webs/*/build.xml"});

					directoryScanner.scan();

					String[] fileNames = directoryScanner.getIncludedFiles();

					List pluginNames = new ArrayList();

					for (String fileName : fileNames) {
						int x = fileName.indexOf("/");
						int y = fileName.lastIndexOf("/");

						if (File.separator.equals("\\")) {
							x = fileName.indexOf("\\");
							y = fileName.lastIndexOf("\\");
						}

						String pluginName = fileName.substring(x + 1, y);

						String pluginsExcludes = project.getProperty("plugins.excludes");

						if (!pluginsExcludes.contains(pluginName)) {
							pluginNames.add(pluginName);
						}
					}

					Collections.sort(pluginNames);

					return pluginNames;
				}

				StringBuilder sb = new StringBuilder();

				int allTestPluginGroupsSize = Integer.parseInt(project.getProperty("test.plugin.groups.size"));

				List pluginNames = getPluginNames();

				List testPluginGroups = getPluginGroups(pluginNames, allTestPluginGroupsSize);

				for (i = 0; i < allTestPluginGroupsSize; i++) {
					List testPluginGroup = testPluginGroups.get(i);

					sb.append("TEST_PLUGIN_GROUP_");
					sb.append(i);
					sb.append("=");

					for (String testPlugin : testPluginGroup) {
						sb.append(testPlugin);
						sb.append(",");
					}

					sb.append("\n\n");
				}

				sb.append("TEST_PLUGIN_GROUPS=");

				for (int i = 0; i < allTestPluginGroupsSize; i++) {
					sb.append(i);
					sb.append(" ");
				}

				if (allTestPluginGroupsSize > 0) {
					sb.setLength(sb.length() - 1);
				}

				project.setProperty("test.plugin.names.properties.content", sb.toString());
			]]>
		</beanshell>

		<echo file="test.plugin.names.properties">${test.plugin.names.properties.content}</echo>
	</target>

	<target name="record-testray-logs">
		<if>
			<isset property="jenkins.testray.results.dir" />
			<then>
				<antcall target="record-testray-logs-jenkins-console" />

				<antcall target="record-testray-logs-poshi-report" />

				<execute>
					gzip -r testray-logs/
				</execute>

				<for list="production" param="testray.base.dir.name">
					<sequential>
						<rsync rsync.dest="testray-results/@{testray.base.dir.name}/logs" rsync.src="testray-logs/." />
					</sequential>
				</for>
			</then>
		</if>
	</target>

	<target name="record-testray-logs-jenkins-console">
		<get-testray-logs-dir-name />

		<mkdir dir="testray-logs/${testray.logs.dir.name}" />

		<propertyregex
			input="${env.BUILD_URL}"
			property="jenkins.build.url"
			regexp="https:\/\/([^\.]+)\.[^\/]+"
			replace="http://\1"
		/>

		<propertyregex
			input="${jenkins.build.url}"
			override="true"
			property="jenkins.build.url"
			regexp="http:\/\/([^\/]+)\/(\d+)"
			replace="http://\1-\2/\2"
		/>

		<get dest="testray-logs/${testray.logs.dir.name}/jenkins-console.txt" ignoreerrors="true" src="${jenkins.build.url}/consoleText" />
	</target>

	<target name="record-testray-logs-poshi-report">
		<if>
			<isset property="test.class" />
			<then>
				<get-poshi-dir-name />

				<get-testray-logs-dir-name />

				<copy todir="testray-logs/${testray.logs.dir.name}">
					<fileset dir="portal-web/test-results/${poshi.dir.name}" erroronmissingdir="false" />
				</copy>

				<replaceregexp flags="g" match="\.jpg" replace=".jpg.gz">
					<fileset dir="testray-logs/${testray.logs.dir.name}" includes="*.html" />
				</replaceregexp>
			</then>
		</if>
	</target>

	<target name="remove-plugin">
		<get-auto-deploy-dir />

		<delete>
			<fileset dir="${auto.deploy.dir}" includes="${plugin.name}-*.war" />
		</delete>
	</target>

	<target name="replace-file">
		<fail message="Please set the property ${file}." unless="file" />
		<fail message="Please set the property ${token}." unless="token" />
		<fail message="Please set the property ${value}." unless="value" />

		<fail message="${token} not found in ${file}.">
			<condition>
				<not>
					<resourcecontains resource="${file}" substring="${token}" />
				</not>
			</condition>
		</fail>

		<echo>Replacing ${token} with ${value} in ${file}.</echo>

		<replace file="${file}">
			<replacefilter
				token="${token}"
				value="${value}"
			/>
		</replace>
	</target>

	<target name="run-poshi-evaluate-console">
		<if>
			<isset property="test.base.dir.name" />
			<then>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties">
					<param name="test.base.dir.name" value="${test.base.dir.name}" />
				</antcall>
			</then>
			<else>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties" />
			</else>
		</if>

		<poshi-execute task="evaluatePoshiConsole" />
	</target>

	<target name="run-poshi-runner">
		<poshi-execute task="runPoshi" />
	</target>

	<target name="run-poshi-validation">
		<delete failonerror="false" file="${test.ext.properties.file}" />

		<if>
			<isset property="test.base.dir.name" />
			<then>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties">
					<param name="test.base.dir.name" value="${test.base.dir.name}" />
				</antcall>
			</then>
			<else>
				<antcall inheritAll="false" target="prepare-poshi-runner-properties" />
			</else>
		</if>

		<poshi-execute task="validatePoshi" />
	</target>

	<target name="run-selenium-smoke-test">
		<antcall target="compile" />

		<ant dir="portal-impl" inheritAll="false" target="compile-test" />

		<ant dir="portal-web" inheritAll="false" target="test-class">
			<property name="test.class" value="SeleniumSmokeTestSuite" />
		</ant>
	</target>

	<target depends="prepare-selenium" name="run-selenium-test">
		<if>
			<and>
				<equals arg1="${test.class}" arg2="PortalWebTestSuite" />
				<not>
					<equals arg1="${database.type}" arg2="hypersonic" />
				</not>
			</and>
			<then>
				<ant dir="portal-impl" inheritAll="false" target="test-class">
					<property name="test.class" value="ServiceHttpTestSuite" />
				</ant>

				<ant dir="portal-impl" inheritAll="false" target="test-class">
					<property name="test.class" value="ServiceSoapTestSuite" />
				</ant>
			</then>
		</if>

		<if>
			<equals arg1="${database.type}" arg2="hypersonic" />
			<then>
				<echo file="portal-impl/classes/portal-ext.properties">liferay.home=${liferay.home}

jdbc.default.jndi.name=

jdbc.default.driverClassName=${database.mysql.driver}
jdbc.default.url=${database.mysql.url}
jdbc.default.username=${database.mysql.username}
jdbc.default.password=${database.mysql.password}</echo>
			</then>
		</if>

		<antcall target="run-poshi-runner" />

		<property name="test.class" value="${test.simple.class.name}#${test.method.name}" />

		<if>
			<isset property="jenkins.shared.user.content.dir" />
			<then>
				<var name="jenkins.shared.results.dir" value="${jenkins.shared.user.content.dir}/jobs" />
			</then>
			<else>
				<var name="jenkins.shared.results.dir" value="." />
			</else>
		</if>

		<if>
			<isset property="env.JENKINS_HOME" />
			<then>
				<antelope:stringutil property="job.name" string="${env.JOB_NAME}">
					<antelope:replace regex="," replacement="_" />
				</antelope:stringutil>

				<get-poshi-class-name />
				<get-poshi-method-name />

				<property name="poshi.runner.results.dir" value="${poshi.class.name}_${poshi.method.name}" />

				<if>
					<available file="portal-web/test-results/${poshi.runner.results.dir}/index.html" />
					<then>
						<copy
							file="portal-web/test-results/${poshi.runner.results.dir}/index.html"
							tofile="${jenkins.shared.results.dir}/${job.name}/builds/${env.BUILD_NUMBER}/report.html"
						/>

						<copy todir="${jenkins.shared.results.dir}/${job.name}/builds/${env.BUILD_NUMBER}/screenshots">
							<fileset dir="portal-web/test-results/${poshi.runner.results.dir}/screenshots" erroronmissingdir="false" />
						</copy>
					</then>
				</if>

				<antcall target="run-poshi-evaluate-console" />

				<if>
					<istrue value="${build.test.results.xml}" />
					<then>
						<antcall target="build-test-results-xml" />

						<first id="first">
							<fileset dir="portal-web/test-results/" includes="**/TEST-com.liferay.portalweb.*.xml,**/TEST-com.liferay.portalweb2.*.xml,**/TEST-com.liferay.poshi.runner.*.xml" />
						</first>

						<property name="jenkins.results.xml.file" value="${toString:first}" />

						<if>
							<and>
								<available file="${jenkins.results.xml.file}" />
								<not>
									<isset property="env.JENKINS_GITHUB_PULL_REQUEST_USERNAME" />
								</not>
							</and>
							<then>
								<copy
									file="${jenkins.results.xml.file}"
									tofile="${jenkins.shared.results.dir}/${env.BUILD_FLOW_JOB_NAME}/builds/${env.BUILD_FLOW_BUILD_NUMBER}/test-results/TEST-${env.BUILD_FLOW_JOB_NAME}_${env.BUILD_FLOW_BUILD_NUMBER}_${test.class}.xml"
								/>
							</then>
						</if>

						<move file="${jenkins.results.xml.file}" todir="${project.dir}/portal-web/test-results/functional" />
					</then>
				</if>
			</then>
		</if>

		<antcall target="clean-up-mobile-device" />

		<antcall target="clean-up-selenium-driver" />
	</target>

	<target name="run-simple-server">
		<if>
			<not>
				<available file="tools/sdk" />
			</not>
			<then>
				<antcall inheritAll="false" target="setup-sdk" />
			</then>
		</if>

		<if>
			<matches pattern="[0-9]+_[0-9]+" string="${test.class}" />
			<then>
				<get-test-class />
			</then>
		</if>

		<get-testcase-property property.name="test.prepare.bundle.properties" />

		<if>
			<equals arg1="${test.prepare.bundle.properties}" arg2="false" />
			<then>
				<delete failonerror="false" file="${app.server.classes.portal.dir}/portal-ext.properties" />

				<echo append="true" file="${app.server.classes.portal.dir}/portal-ext.properties">

module.framework.properties.blacklist.portal.profile.names=${blacklist.portal.profile.names}</echo>

				<delete failonerror="false" file="${app.server.classes.portal.dir}/system-ext.properties" />
			</then>
			<else>
				<antcall target="prepare-osgi-module-configurations" />

				<antcall target="prepare-portal-properties" />

				<antcall target="prepare-portal-ext-properties" />

				<antcall target="prepare-portlet-ext-properties" />

				<antcall target="prepare-system-ext-properties" />
			</else>
		</if>

		<if>
			<equals arg1="${app.server.type}" arg2="tomcat" />
			<then>
				<ant antfile="build-dist.xml" target="update-java-security-tomcat" />
			</then>
		</if>

		<antcall target="check-inet-address" />

		<get-testcase-property property.name="database.jndi.enabled" />

		<if>
			<equals arg1="${database.jndi.enabled}" arg2="true" />
			<then>
				<prepare-database-jndi />
			</then>
		</if>

		<get-testcase-property property.name="portal.context" />

		<if>
			<isset property="portal.context" />
			<then>
				<if>
					<equals arg1="${app.server.type}" arg2="tomcat" />
					<then>
						<move todir="${app.server.dir}/webapps/${portal.context}">
							<fileset dir="${app.server.dir}/webapps/ROOT" />
						</move>
						<move file="${app.server.dir}/conf/Catalina/localhost/ROOT.xml" tofile="${app.server.dir}/conf/Catalina/localhost/${portal.context}.xml" />
						<replace file="${app.server.dir}/conf/Catalina/localhost/${portal.context}.xml" token="path=&quot;&quot;" value="path=&quot;/${portal.context}&quot;" />
					</then>
					<else>
						<fail message="Changing the portal context for ${app.server.type} is not supported." />
					</else>
				</if>
			</then>
		</if>

		<get-testcase-property property.name="portal.ssl.enabled" />

		<if>
			<equals arg1="${portal.ssl.enabled}" arg2="true" />
			<then>
				<if>
					<equals arg1="${app.server.type}" arg2="tomcat" />
					<then>
						<if>
							<os family="unix" />
							<then>
								<exec dir="${app.server.parent.dir}" executable="/bin/bash">
									<arg value="-c" />
									<arg value="keytool -genkey -alias tomcat -dname CN=localhost -keyalg RSA -keypass liferay -storepass liferay -keystore keystore.jks" />
								</exec>
							</then>
							<elseif>
								<os family="windows" />
								<then>
									<exec dir="${app.server.parent.dir}" executable="cmd">
										<arg value="/c" />
										<arg value="keytool -genkey -alias tomcat -dname CN=localhost -keyalg RSA -keypass liferay -storepass liferay -keystore keystore.jks" />
									</exec>
								</then>
							</elseif>
						</if>

						<replace
							file="${app.server.dir}/conf/server.xml"
							token="&lt;Service name=&quot;Catalina&quot;&gt;"
							value="&lt;Service name=&quot;Catalina&quot;&gt;${line.separator}    &lt;Connector port=&quot;8443&quot; protocol=&quot;org.apache.coyote.http11.Http11Protocol&quot;${line.separator}           maxThreads=&quot;150&quot; SSLEnabled=&quot;true&quot; scheme=&quot;https&quot; secure=&quot;true&quot;${line.separator}           clientAuth=&quot;false&quot; sslProtocol=&quot;TLS&quot; keystoreFile=&quot;${app.server.parent.dir}/keystore.jks&quot; keystorePass=&quot;liferay&quot; /&gt;"
						/>
					</then>
					<else>
						<fail message="Enabling SSL for ${app.server.type} is not supported." />
					</else>
				</if>
			</then>
		</if>

		<get-testcase-property property.name="web.xml.timeout" />

		<if>
			<isset property="web.xml.timeout" />
			<then>
				<if>
					<equals arg1="${app.server.type}" arg2="tomcat" />
					<then>
						<replace
							file="${app.server.dir}/webapps/ROOT/WEB-INF/web.xml"
							token="&lt;session-timeout&gt;30&lt;/session-timeout&gt;"
							value="&lt;session-timeout&gt;${web.xml.timeout}&lt;/session-timeout&gt;"
						/>
					</then>
					<else>
						<fail message="Changing the session timeout for ${app.server.type} is not supported." />
					</else>
				</if>
			</then>
		</if>

		<if>
			<not>
				<equals arg1="${os.name}" arg2="SunOS" />
			</not>
			<then>
				<antcall inheritAll="false" target="clean-up-java-processes" />
			</then>
		</if>

		<antcall inheritAll="false" target="copy-optional-jars">
			<param name="todir" value="${app.server.lib.global.dir}" />
		</antcall>

		<get-testcase-property property.name="portal.version" />

		<if>
			<isset property="portal.version" />
			<then>
				<antcall target="rebuild-legacy-database" />

				<antcall target="upgrade-legacy-database" />
			</then>
			<else>
				<antcall inheritAll="false" target="rebuild-database" />
			</else>
		</if>

		<get-testcase-property property.name="skip.clean-app-server-deploy-dir" />

		<if>
			<not>
				<equals arg1="${skip.clean-app-server-deploy-dir}" arg2="true" />
			</not>
			<then>
				<antcall target="clean-app-server-deploy-dir" />
			</then>
		</if>

		<if>
			<equals arg1="${app.server.type}" arg2="glassfish" />
			<then>
				<start-app-server />

				<stop-app-server />
			</then>
		</if>

		<get-testcase-property property.name="apacheds.blank.user.password.enabled" />
		<get-testcase-property property.name="apacheds.enabled" />

		<if>
			<or>
				<equals arg1="${apacheds.blank.user.password.enabled}" arg2="true" />
				<equals arg1="${apacheds.enabled}" arg2="true" />
			</or>
			<then>
				<ant antfile="build-test-apacheds.xml" target="start-apacheds" />
			</then>
		</if>

		<get-testcase-property property.name="openam.enabled" />

		<if>
			<equals arg1="${openam.enabled}" arg2="true" />
			<then>
				<ant antfile="build-test-authentication.xml" target="delete-openam-config" />

				<ant antfile="build-test-authentication.xml" target="setup-openam" />
			</then>
		</if>

		<get-testcase-property property.name="remote.elasticsearch.enabled" />

		<if>
			<equals arg1="${remote.elasticsearch.enabled}" arg2="true" />
			<then>
				<ant antfile="build-test-elasticsearch.xml" target="start-elasticsearch" />

				<get-testcase-property property.name="elastic.kibana.enabled" />

				<if>
					<equals arg1="${elastic.kibana.enabled}" arg2="true" />
					<then>
						<ant antfile="build-test-elasticsearch.xml" target="start-kibana" />
					</then>
				</if>
			</then>
		</if>

		<get-testcase-property property.name="solr.enabled" />

		<if>
			<equals arg1="${solr.enabled}" arg2="true" />
			<then>
				<ant antfile="build-test-solr.xml" target="start-solr" />
			</then>
		</if>

		<get-testcase-property property.name="test.smtp.server.enabled" />

		<if>
			<equals arg1="${test.smtp.server.enabled}" arg2="true" />
			<then>
				<start-test-smtp-server />
			</then>
		</if>

		<if>
			<equals arg1="${test.latest.marketplace.apps}" arg2="true" />
			<then>
				<antcall target="deploy-latest-marketplace-apps" />
			</then>
		</if>

		<get-testcase-property property.name="cmis.repository.type" />

		<if>
			<or>
				<equals arg1="${cmis.repository.type}" arg2="documentum6" />
				<equals arg1="${cmis.repository.type}" arg2="sharepoint2010" />
				<equals arg1="${cmis.repository.type}" arg2="sharepoint2013" />
			</or>
			<then>
				<request-cmis-repository-vm
					cmis.repository.type="${cmis.repository.type}"
				/>
			</then>
		</if>

		<antcall target="deploy-osgi-apps" />

		<antcall target="deploy-osgi-modules" />

		<antcall target="deploy-specified-plugins">
			<param name="test.class" value="${test.class}" />
		</antcall>

		<antcall target="deploy-dependency-jars" />

		<antcall target="deploy-extra-apps" />

		<get-testcase-property property.name="osgi.module.configuration.file.names" />
		<get-testcase-property property.name="osgi.module.configurations" />

		<if>
			<and>
				<isset property="osgi.module.configuration.file.names" />
				<isset property="osgi.module.configurations" />
			</and>
			<then>
				<antcall target="deploy-osgi-module-configurations" />
			</then>
		</if>

		<get-testcase-property property.name="app.server.bundles.size" />

		<if>
			<isset property="app.server.bundles.size" />
			<then>
				<prepare-additional-bundles />
			</then>
		</if>

		<get-testcase-property property.name="cluster.enabled" />

		<if>
			<equals arg1="${cluster.enabled}" arg2="true" />
			<then>
				<prepare-test-cluster-properties />

				<get-testcase-property property.name="test.run.environment" />

				<if>
					<equals arg1="${test.run.environment}" arg2="CE" />
					<then>
						<delete>
							<fileset dir="${liferay.home}/osgi/portal" includes="*.single.jar" />
						</delete>
					</then>
				</if>
			</then>
		</if>

		<get-testcase-property property.name="hook.plugins.includes" />

		<if>
			<and>
				<contains string="${hook.plugins.includes}" substring="so-hook" />
				<or>
					<equals arg1="${app.server.type}" arg2="jboss" />
					<equals arg1="${app.server.type}" arg2="wildfly" />
				</or>
			</and>
			<then>
				<start-app-server />

				<stop-app-server />
			</then>
		</if>

		<remake-dir dir="${selenium.output.dir.name}" />

		<get-testcase-property property.name="skip.start-app-server" />

		<if>
			<not>
				<equals arg1="${skip.start-app-server}" arg2="true" />
			</not>
			<then>
				<get-testcase-property property.name="theme.file.name" />

				<if>
					<isset property="theme.file.name" />
					<then>
						<mkdir dir="${liferay.home}/tmp" />

						<move todir="${liferay.home}/tmp">
							<fileset dir="${liferay.home}/deploy" includes="${theme.file.name}" />
						</move>

						<move todir="${liferay.home}/tmp">
							<fileset dir="${liferay.home}/osgi/marketplace" includes="*Theme*.lpkg" />
						</move>
					</then>
				</if>

				<start-app-server />

				<get-testcase-property property.name="app.server.bundles.size" />

				<if>
					<isset property="app.server.bundles.size" />
					<then>
						<var name="app.server.bundle.index" value="1" />

						<antelope:repeat count="${app.server.bundles.size}">
							<start-app-server
								app.server.bundle.index="${app.server.bundle.index}"
							/>

							<math
								datatype="int"
								operand1="${app.server.bundle.index}"
								operand2="1"
								operation="+"
								result="app.server.bundle.index"
							/>
						</antelope:repeat>

						<var name="app.server.bundle.index" unset="true" />
					</then>
				</if>

				<if>
					<not>
						<equals arg1="${tcat.enabled}" arg2="true" />
					</not>
					<then>
						<waitfor maxwait="150" maxwaitunit="second">
							<available file="${liferay.home}/logs" type="dir" />
						</waitfor>

						<antcall target="wait-for-plugins-deployment" />
					</then>
				</if>

				<if>
					<available file="${liferay.home}/tmp/${theme.file.name}" />
					<then>
						<move todir="${liferay.home}/deploy">
							<fileset dir="${liferay.home}/tmp" includes="${theme.file.name}" />
						</move>

						<delete dir="${liferay.home}/tmp" failonerror="false" />

						<waitfor checkevery="5" maxwait="300" maxwaitunit="second" timeoutproperty="theme.not.deployed">
							<available file="${liferay.home}/osgi/war/${theme.file.name}" />
						</waitfor>

						<fail if="theme.not.deployed" message="${theme.file.name} has failed to deploy." />
					</then>
					<elseif>
						<available file="${liferay.home}/tmp" type="dir" />
						<then>
							<move todir="${liferay.home}/osgi/marketplace">
								<fileset dir="${liferay.home}/tmp" includes="*Theme*.lpkg" />
							</move>

							<delete dir="${liferay.home}/tmp" failonerror="false" />
						</then>
					</elseif>
				</if>
			</then>
		</if>

		<antcall target="run-selenium-test" />

		<get-testcase-property property.name="cmis.repository.type" />

		<if>
			<or>
				<equals arg1="${cmis.repository.type}" arg2="documentum6" />
				<equals arg1="${cmis.repository.type}" arg2="sharepoint2010" />
				<equals arg1="${cmis.repository.type}" arg2="sharepoint2013" />
			</or>
			<then>
				<property file="${project.dir}/${test.ext.properties.file}" />

				<if>
					<contains string="${cmis.repository.type}" substring="documentum" />
					<then>
						<ssh-execute ssh.host="${cmis.repository.vm.host.name}">perl C:/Windows/resetdocumentum.pl</ssh-execute>
					</then>
					<elseif>
						<contains string="${cmis.repository.type}" substring="sharepoint" />
						<then>
							<ssh-execute ssh.host="${cmis.repository.vm.host.name}">perl C:/Windows/resetsharepointrepo.pl</ssh-execute>
						</then>
					</elseif>
				</if>

				<if>
					<os family="unix" />
					<then>
						<exec executable="/bin/bash" os="${os.unix}">
							<arg value="-c" />
							<arg value="curl &quot;http://it.liferay.com/osb-ici-controller-web/vm/allocation/release?hostname=${cmis.repository.vm.host.name}&amp;resourceType=qa%2E${cmis.repository.type}&quot;" />
						</exec>
					</then>
					<else>
						<exec executable="cmd">
							<arg value="/c" />
							<arg value="curl &quot;http://it.liferay.com/osb-ici-controller-web/vm/allocation/release?hostname=${cmis.repository.vm.host.name}&amp;resourceType=qa%2E${cmis.repository.type}&quot;" />
						</exec>
					</else>
				</if>
			</then>
		</if>

		<stop-app-server />

		<get-testcase-property property.name="app.server.bundles.size" />

		<if>
			<isset property="app.server.bundles.size" />
			<then>
				<var name="app.server.bundle.index" value="1" />

				<antelope:repeat count="${app.server.bundles.size}">
					<stop-app-server
						app.server.bundle.index="${app.server.bundle.index}"
					/>

					<math
						datatype="int"
						operand1="${app.server.bundle.index}"
						operand2="1"
						operation="+"
						result="app.server.bundle.index"
					/>
				</antelope:repeat>

				<var name="app.server.bundle.index" unset="true" />
			</then>
		</if>

		<get-testcase-property property.name="apacheds.enabled" />

		<if>
			<equals arg1="${apacheds.enabled}" arg2="true" />
			<then>
				<ant antfile="build-test-apacheds.xml" target="stop-apacheds" />
			</then>
		</if>

		<get-testcase-property property.name="elastic.kibana.enabled" />

		<if>
			<equals arg1="${elastic.kibana.enabled}" arg2="true" />
			<then>
				<print-file file.name="${elastic.kibana.dir}/bin/kibana.log" />

				<ant antfile="build-test-elasticsearch.xml" target="stop-kibana" />
			</then>
		</if>

		<get-testcase-property property.name="openam.enabled" />

		<if>
			<equals arg1="${openam.enabled}" arg2="true" />
			<then>
				<ant antfile="build-test-authentication.xml" target="delete-openam-config" />
			</then>
		</if>

		<get-testcase-property property.name="remote.elasticsearch.enabled" />

		<if>
			<equals arg1="${remote.elasticsearch.enabled}" arg2="true" />
			<then>
				<print-file file.name="${elasticsearch.dir}/logs/LiferayElasticsearchCluster.log" />

				<get
					dest="${elasticsearch.dir}/logs/LiferayElasticsearchClusterMappings.log"
					src="http://localhost:9200/_all/_mapping?pretty"
				/>

				<print-file file.name="${elasticsearch.dir}/logs/LiferayElasticsearchClusterMappings.log" />

				<ant antfile="build-test-elasticsearch.xml" target="stop-elasticsearch" />
			</then>
		</if>

		<get-testcase-property property.name="solr.enabled" />

		<if>
			<equals arg1="${solr.enabled}" arg2="true" />
			<then>
				<ant antfile="build-test-solr.xml" target="stop-solr-core" />
			</then>
		</if>

		<antcall target="clean-up-web-xml" />
	</target>

	<target name="set-portal-impl-portal-test-ext-properties">
		<set-portal-impl-portal-test-ext-properties />
	</target>

	<target name="set-tomcat-version-number">
		<set-tomcat-version-number liferay.portal.bundle="${liferay.portal.bundle}" />
	</target>

	<target name="setup-testable-tomcat">
		<setup-testable-tomcat />
	</target>

	<target name="start-app-server">
		<if>
			<not>
				<isset property="app.server.bundle.index" />
			</not>
			<then>
				<var name="app.server.bundle.index" value="0" />
			</then>
		</if>

		<start-app-server
			app.server.bundle.index="${app.server.bundle.index}"
			testable.portal.started.marker.file="${testable.portal.started.marker.file}"
		/>
	</target>

	<target name="start-app-server-preserve-liferay-home">
		<if>
			<not>
				<isset property="app.server.bundle.index" />
			</not>
			<then>
				<var name="app.server.bundle.index" value="0" />
			</then>
		</if>

		<start-app-server
			app.server.bundle.index="${app.server.bundle.index}"
			delete.liferay.home="false"
			testable.portal.started.marker.file="${testable.portal.started.marker.file}"
		/>
	</target>

	<target name="start-lcs-server">
		<start-lcs-app-server
			app.server.bin.dir="${app.server.parent.dir}/gateway/tomcat-${app.server.tomcat.version}/bin"
			app.server.bundle.index="1"
			app.server.leading.port.number="7"
		/>

		<start-lcs-app-server
			app.server.bin.dir="${app.server.parent.dir}/processor/tomcat-${app.server.tomcat.version}/bin"
			app.server.bundle.index="2"
			app.server.leading.port.number="9"
		/>

		<start-lcs-app-server />
	</target>

	<target name="start-test-smtp-server">
		<start-test-smtp-server />
	</target>

	<target name="stop-app-server">
		<if>
			<not>
				<isset property="app.server.bundle.index" />
			</not>
			<then>
				<var name="app.server.bundle.index" value="0" />
			</then>
		</if>

		<stop-app-server
			app.server.bundle.index="${app.server.bundle.index}"
		/>
	</target>

	<target name="stop-lcs-server">
		<stop-lcs-app-server
			app.server.bin.dir="${app.server.parent.dir}/gateway/tomcat-${app.server.tomcat.version}/bin"
			app.server.bundle.index="1"
			app.server.leading.port.number="7"
		/>

		<stop-lcs-app-server
			app.server.bin.dir="${app.server.parent.dir}/processor/tomcat-${app.server.tomcat.version}/bin"
			app.server.bundle.index="2"
			app.server.leading.port.number="9"
		/>

		<stop-lcs-app-server />
	</target>

	<target name="test-integration">
		<ant dir="portal-kernel" inheritAll="false" target="test-integration" />

		<ant dir="portal-impl" inheritAll="false" target="test-integration" />

		<ant dir="util-java" inheritAll="false" target="test-integration" />
	</target>

	<target name="test-package">
		<ant dir="portal-kernel" inheritAll="false" target="test-package" />

		<ant dir="portal-impl" inheritAll="false" target="test-package" />

		<ant dir="util-java" inheritAll="false" target="test-package" />
	</target>

	<target name="test-unit">
		<ant dir="portal-kernel" inheritAll="false" target="test-unit" />

		<ant dir="portal-impl" inheritAll="false" target="test-unit" />

		<ant dir="util-java" inheritAll="false" target="test-unit" />
	</target>

	<target name="uninstall-patches">
		<uninstall-patches patching.tool.dir="${app.server.parent.dir}/patching-tool" />
	</target>

	<target name="upgrade-legacy-database">
		<delete file="${liferay.home}/osgi/configs/com.liferay.portal.search.configuration.IndexStatusManagerConfiguration.cfg" />
		<delete file="${liferay.home}/tools/portal-tools-db-upgrade-client/upgrade.log" />

		<echo file="${liferay.home}/osgi/configs/com.liferay.portal.search.configuration.IndexStatusManagerConfiguration.cfg">indexReadOnly=true</echo>

		<if>
			<equals arg1="${app.server.type}" arg2="jboss" />
			<then>
				<echo file="${liferay.home}/tools/portal-tools-db-upgrade-client/app-server.properties">dir=${app.server.dir}
extra.lib.dirs=modules/system/layers/base/javax/mail,modules/system/layers/base/javax/persistence,modules/system/layers/base/javax/servlet,modules/system/layers/base/javax/transaction
global.lib.dir=modules/com/liferay/portal/main
portal.dir=standalone/deployments/ROOT.war
server.detector.server.id=jboss</echo>
			</then>
			<elseif>
				<equals arg1="${app.server.type}" arg2="tomcat" />
				<then>
					<echo file="${liferay.home}/tools/portal-tools-db-upgrade-client/app-server.properties">dir=${app.server.dir}
extra.lib.dirs=bin
global.lib.dir=lib
portal.dir=webapps/ROOT
server.detector.server.id=tomcat</echo>
				</then>
			</elseif>
			<elseif>
				<equals arg1="${app.server.type}" arg2="wildfly" />
				<then>
					<echo file="${liferay.home}/tools/portal-tools-db-upgrade-client/app-server.properties">dir=${app.server.dir}
extra.lib.dirs=modules/system/layers/base/javax/mail,modules/system/layers/base/javax/persistence,modules/system/layers/base/javax/servlet,modules/system/layers/base/javax/transaction
global.lib.dir=modules/com/liferay/portal/main
portal.dir=standalone/deployments/ROOT.war
server.detector.server.id=wildfly</echo>
				</then>
			</elseif>
		</if>

		<get-database-property property.name="database.driver" />
		<get-database-property property.name="database.password" />
		<get-database-property property.name="database.url" />
		<get-database-property property.name="database.username" />

		<echo file="${liferay.home}/tools/portal-tools-db-upgrade-client/portal-upgrade-database.properties">jdbc.default.driverClassName=${database.driver}
jdbc.default.url=${database.url}
jdbc.default.username=${database.username}
jdbc.default.password=${database.password}</echo>

		<echo file="${liferay.home}/tools/portal-tools-db-upgrade-client/portal-upgrade-ext.properties">liferay.home=${liferay.home}</echo>

		<trycatch property="upgrade.error">
			<try>
				<java
					dir="${liferay.home}/tools/portal-tools-db-upgrade-client"
					failonerror="true"
					fork="true"
					jar="${liferay.home}/tools/portal-tools-db-upgrade-client/com.liferay.portal.tools.db.upgrade.client.jar"
					timeout="900000"
				/>
			</try>
			<catch>
				<get-jstack-output process.name="DBUpgrader" />

				<fail message="${upgrade.error}${line.separator}${jstack.output}" />
			</catch>
		</trycatch>

		<echo file="${liferay.home}/osgi/configs/com.liferay.portal.search.configuration.IndexStatusManagerConfiguration.cfg">indexReadOnly=false</echo>
	</target>

	<target name="wait-for-plugins-deployment">
		<fail message="Please set the property ${test.class}." unless="test.class" />

		<if>
			<not>
				<equals arg1="${liferay.portal.bundle}" arg2="6.0.6" />
			</not>
			<then>
				<condition property="required.plugins.includes" value="">
					<not>
						<isset property="required.plugins.includes" />
					</not>
				</condition>

				<if>
					<not>
						<available file="${liferay.home}/logs" type="dir" />
					</not>
					<then>
						<fail message="${liferay.home}/logs is not available." />
					</then>
				</if>

				<first id="first">
					<fileset dir="${liferay.home}/logs" includes="*.log" />
				</first>

				<var name="log.file.path" value="${toString:first}" />

				<get-testcase-property property.name="hook.plugins.includes" />
				<get-testcase-property property.name="layouttpl.plugins.includes" />
				<get-testcase-property property.name="portlet.plugins.includes" />
				<get-testcase-property property.name="theme.plugins.includes" />
				<get-testcase-property property.name="web.plugins.includes" />

				<beanshell>
					<![CDATA[
						import org.apache.commons.io.FileUtils;

						Set requiredPluginNamesSet = new HashSet();

						String[] pluginTypes = {"hook", "layouttpl", "portlet", "required", "theme", "web"};

						for (String pluginType : pluginTypes) {
							String pluginNamesString = project.getProperty(pluginType + ".plugins.includes");

							if (pluginNamesString != null) {
								String[] pluginNames = pluginNamesString.split(",");

								for (String pluginName : pluginNames) {
									requiredPluginNamesSet.add(pluginName);
								}
							}
						}

						System.out.println("Ensuring the following plugins have been deployed:");
						System.out.println(requiredPluginNamesSet);

						String logFilePath = project.getProperty("log.file.path");

						logFilePath = logFilePath.replaceAll("\\\\", "/");

						int second = 0;

						for (String pluginName : requiredPluginNamesSet) {
							while (true) {
								try {
									File file = new File(logFilePath);

									String content = FileUtils.readFileToString(file);

									if (content.contains(pluginName + " is available for use") ||
										content.contains(pluginName + " are available for use")) {

										break;
									}
								}
								catch (Exception e) {
									e.printStackTrace();
								}

								if (second >= 120) {
									break;
								}

								second++;

								Thread.sleep(1000);
							}
						}
					]]>
				</beanshell>
			</then>
		</if>
	</target>
</project>