blob: 2a027bb008c4903e793f831489b35678221a2ee3 [file] [log] [blame]
<?xml version="1.0"?>
<!--/*******************************************************************************
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Ant naming conventions:
* - regardless of the actual OS platform,'/' is the directory separator
* (Ant will convert as appropriate).
* - multi-word properties use periods '.'
* - properties ending in .jar define jarfile names only (no path)
* - properties ending in .lib are fully qualified jars (path and filename)
* - properties ending in .dir are directory paths
* - properties ending in .path are path refid names (classpath fragments)
* - multi-word targets use hyphens '-'
* - targets beginning with test- are reserved for high level test targets,
* and are used in test results parsing
* - targets typically use the form <action>-<object>-<type> (ie. package-bundle-zip)
* - multi-word macros use underscores '_'
* - multi-word macro attributes are concatenated
* e.g. 'runpathref'
* - multi-word tasks (taskdef) names are concatenated
* e.g. 'validateconnection'
* - OS environment variables are in ALLCAPS and have 'env' as a prefix
* e.g. ${env.XXX}.
* - Ant properties are lower case.
*
* Contributors:
* tware - initial API and implementation
* egwin - update to adopt calling standards
#******************************************************************************/-->
<!-- This ant project includes the following tasks:
- build (default) : cleans, compiles, and packages all tests
- clean : cleans up all generated files and dirs
- compile : compiles all tests
- package : packages test jar
- process.resource : translates login info in resources into run directory
- test : runs LRG
- test-lrg : runs LRG
- test-srg : runs SRG
It requires some configuration of the build.properties and test.properties to run.
-->
<project name="eclipselink.core.test" default="build" basedir=".">
<echo message="CORETEST_BEGINS..."/>
<available file="../${ant.project.name}" type="dir" property="core_test.is.local"/>
<fail message="Not running from '${ant.project.name}' directory" unless="core_test.is.local"/>
<dirname property="core_test.build.location_temp" file="${ant.file.eclipselink.core.test}"/>
<pathconvert targetos="unix" property="core_test.build.location">
<path>
<pathelement location="${core_test.build.location_temp}"/>
</path>
</pathconvert>
<echo message="core_test.build.location = '${core_test.build.location}'"/>
<condition property="core_test.2.base.dir" value="../.." else="..">
<contains string="${core_test.build.location}" substring="foundation"/>
</condition>
<echo message="core_test.2.base.dir = '${core_test.2.base.dir}'"/>
<property name="core_test.2.common.plugins.dir" value="${core_test.2.base.dir}/plugins"/>
<property name="core_test.2.core.dir" value="../org.eclipse.persistence.core"/>
<property name="core_test.plugins.dir" value="../plugins"/>
<!-- Allows tools.jar to be relative to JAVA_HOME. -->
<property environment="env"/>
<!-- Allows a user to overide certain user specific properties. -->
<condition property="custom.bld.properties.message" value="Loading ${user.home}/build.properties..."
else="Notice: custom properties file '${user.home}/build.properties' not found to load.">
<available file="${user.home}/build.properties"/>
</condition>
<echo message="${custom.bld.properties.message}"/>
<property file="${user.home}/build.properties"/>
<condition property="custom.tst.properties.message" value="Loading ${user.home}/test.properties..."
else="Notice: custom properties file '${user.home}/test.properties' not found to load.">
<available file="${user.home}/test.properties"/>
</condition>
<echo message="${custom.tst.properties.message}"/>
<property file="${user.home}/test.properties"/>
<property file="${core_test.build.location}/antbuild.properties"/>
<property file="${core_test.build.location}/${test.properties}"/>
<property file="${core_test.build.location}/test.properties"/>
<!-- Local path variables -->
<property name="core_test.src.dir" value="${core_test.build.location}/${src.dir}"/>
<property name="core_test.resource.dir" value="${core_test.build.location}/${resource.dir}"/>
<property name="core_test.classes.dir" value="${core_test.build.location}/${classes.dir}"/>
<property name="core_test.report.dir" value="${core_test.build.location}/${report.dir}"/>
<property name="core_test.run.dir" value="${core_test.build.location}/${run.dir}"/>
<!-- Default ant target, compiles and translates resources, does not run tests. -->
<target name="build" depends="clean, compile, package" description="build EclipseLink jar"/>
<!-- Clean all build generated content. -->
<target name="clean" description="Clean the build">
<echo message="Cleaning..."/>
<echo message=" ${core_test.classes.dir}"/>
<echo message=" ${core_test.report.dir}"/>
<echo message=" ${core_test.run.dir}"/>
<echo message=" ${core_test.build.location}/${coretest.framework.jar}"/>
<echo message=" ${core_test.build.location}/${core.test.jar}"/>
<delete includeEmptyDirs="true" failonerror="false">
<fileset dir="${core_test.classes.dir}"/>
<fileset dir="${core_test.report.dir}"/>
<fileset dir="${core_test.run.dir}"/>
<fileset dir="${core_test.build.location}" includes="${coretest.framework.jar}"/>
<fileset dir="${core_test.build.location}" includes="${core.test.jar}"/>
</delete>
</target>
<target name="init">
<!-- Give this a default value if not set in a user.home or test property file -->
<property name="extensions.depend.dir" value="../${core_test.2.base.dir}/extension.lib.external"/>
<property name="junit.lib" value="${extensions.depend.dir}/junit.jar"/>
<echo message="core_test.src.dir ='${core_test.src.dir}'"/>
<echo message="core_test.resource.dir='${core_test.resource.dir}'"/>
<echo message="core_test.classes.dir ='${core_test.classes.dir}'"/>
<echo message="core_test.report.dir ='${core_test.report.dir}'"/>
<echo message="core_test.run.dir ='${core_test.run.dir}'"/>
<echo message="user.home ='${user.home}'"/>
<echo message="test.properties='${test.properties}'"/>
<echo message="extensions.depend.dir ='${extensions.depend.dir}'"/>
<echo message="junit.lib ='${junit.lib}'"/>
<echo message="tools.lib ='${tools.lib}'"/>
<!-- versioning -->
<!-- These variables are set in autobuild.xml. A manual build gets defaults -->
<tstamp>
<format property="build.date" pattern="yyyyMMdd"/>
<format property="build.time" pattern="HHmm"/>
</tstamp>
<property name="build.type" value="SNAPSHOT"/>
<property name="svn.revision" value="NA"/>
<property name="version.qualifier" value="qualifier"/>
<property name="version.string" value="${release.version}.${version.qualifier}"/>
<property name="release.designation" value="EclipseLink ${release.version} Build"/>
<!-- Determine availability of compile dependencies -->
<available file="${core_test.2.common.plugins.dir}/${antlr}_${version.string}.jar" property="antlr.bundle.exist"/>
<available file="${core_test.2.common.plugins.dir}/${asm}_${version.string}.jar" property="asm.bundle.exist"/>
<available file="${core_test.2.common.plugins.dir}/org.eclipse.persistence.core_${version.string}.jar" property="core.bundle.exist"/>
<available file="${core_test.2.base.dir}/${eclipselink.jar}" property="eclipselink.jar.exist"/>
<available file="${core_test.2.core.dir}/${classes.dir}" type="dir" property="core.classes.exist"/>
<available file="${junit.lib}" property="junit.jar.exist"/>
<available file="${core_test.2.common.plugins.dir}/${unsigned.persistence10.jar}" property="persistence.bundle.exist"/>
<!-- Determine availability of runtime dependencies -->
<available file="${eclipselink.core}/${resource.dir}" type="dir" property="core.resources.exist"/>
<available file="${jdbc.driver.jar}" property="jdbc.jar.exist"/>
<available file="${tools.lib}" property="tools.jar.exist"/>
<!-- Determine where to get product classes, based upon availability -->
<condition property="use.eclipselink">
<isset property="eclipselink.jar.exist"/>
</condition>
<condition property="use.bundles">
<and>
<isset property="antlr.bundle.exist"/>
<isset property="asm.bundle.exist"/>
<isset property="core.bundle.exist"/>
<not> <isset property="use.eclipselink"/> </not>
</and>
</condition>
<condition property="use.classes">
<and>
<isset property="core.resources.exist"/>
<isset property="core.classes.exist"/>
<not> <isset property="use.eclipselink"/> </not>
<not> <isset property="use.bundles"/> </not>
</and>
</condition>
<condition property="use.failed">
<and>
<not> <isset property="use.eclipselink"/> </not>
<not> <isset property="use.bundles"/> </not>
<not> <isset property="use.classes"/> </not>
</and>
</condition>
<!-- Determine where to get product classes, based upon availability -->
<condition property="run.ok">
<and>
<not> <isset property="use.failed"/> </not>
<isset property="jdbc.jar.exist"/>
<isset property="tools.jar.exist"/>
</and>
</condition>
<!-- Can be set e.g. in test.properties to add VM options for a particular platform/driver -->
<property name="additional.jvmargs" value="-Ddummy2=dummy"/>
</target>
<target name="init_eclipselink" if="use.eclipselink">
<echo message="Using EclipseLink.jar as 'product' in compile dependency."/>
<path id="core_test.product.path">
<pathelement path="${core_test.2.base.dir}/${eclipselink.jar}"/>
</path>
</target>
<target name="init_bundles" if="use.bundles">
<echo message="Using EclipseLink OSGi bundles as 'product' in compile dependency."/>
<path id="core_test.product.path">
<pathelement path="${core_test.2.common.plugins.dir}/${antlr}_${version.string}.jar"/>
<pathelement path="${core_test.2.common.plugins.dir}/${asm}_${version.string}.jar"/>
<pathelement path="${core_test.2.common.plugins.dir}/org.eclipse.persistence.core_${version.string}.jar"/>
</path>
</target>
<target name="init_classes" if="use.classes">
<echo message="Using EclipseLink classes directly as 'product' in compile dependency."/>
<path id="core_test.product.path">
<pathelement path="${core_test.2.common.plugins.dir}/${antlr}"/>
<pathelement path="${core_test.2.common.plugins.dir}/${asm}"/>
<pathelement path="${core_test.2.core.dir}/${classes.dir}"/>
<pathelement path="${eclipselink.core}/${resource.dir}"/>
</path>
</target>
<target name="init_paths" depends="init, init_eclipselink, init_bundles, init_classes">
<fail message="Product classes do not exist anywhere! Compile product or populate jars." if="use.failed"/>
<path id="core_test.compile.without.connector.path">
<path refid="core_test.product.path"/>
<pathelement path="${junit.lib}"/>
<pathelement path="${core_test.2.common.plugins.dir}/${unsigned.persistence10.jar}"/>
<fileset dir="${core_test.2.common.plugins.dir}" includes="${eclipselink.core.depend.without.connector}"/>
</path>
<path id="core_test.compile.path">
<path refid="core_test.compile.without.connector.path"/>
<pathelement path="${core_test.2.common.plugins.dir}/${connector.jar}"/>
</path>
<path id="core_test.runtime.only.path">
<pathelement path="${core_test.build.location}/${coretest.framework.jar}"/>
<pathelement path="${core_test.build.location}/${core.test.jar}"/>
<pathelement path="${core_test.run.dir}"/>
<pathelement path="${jdbc.driver.jar}"/>
<pathelement path="${tools.lib}"/>
</path>
<path id="core_test.run.path">
<path refid="core_test.compile.path"/>
<path refid="core_test.runtime.only.path"/>
</path>
</target>
<!-- Compiles all tests. -->
<target name="compile" depends="init_paths" description="compile EclipseLink core tests">
<!-- fail message="Cannot find junit: '${junit.lib}'." unless="junit.jar.exist"/ -->
<!-- fail message="Cannot find persistence: '${core_test.2.common.plugins.dir}/${unsigned.persistence10.jar}'." unless="persistence.bundle.exist"/ -->
<mkdir dir="${core_test.classes.dir}"/>
<javac srcdir="${core_test.src.dir}"
destdir="${core_test.classes.dir}"
includes="org/eclipse/persistence/**, deprecated/**, java/sql/**"
debug="${javac.debug}"
debuglevel="${javac.debuglevel}"
encoding="UTF-8"
optimize="${javac.optimize}"
source="${javac.version}"
target="${javac.version}"
deprecation="${javac.deprecation}"
failonerror="true"
memoryMaximumSize="512m"
fork="true"
classpathref="core_test.compile.path"
/>
</target>
<!-- Packages tests jar. -->
<target name="package" depends="compile, process-resource" description="jar for local testing">
<delete file="${core_test.build.location}/${coretest.framework.jar}" failonerror="false"/>
<jar jarfile="${core_test.build.location}/${coretest.framework.jar}">
<fileset dir="${core_test.classes.dir}" includes="org/eclipse/persistence/testing/framework/**/*.class"/>
</jar>
<delete file="${core_test.build.location}/${core.test.jar}" failonerror="false"/>
<jar jarfile="${core_test.build.location}/${core.test.jar}">
<fileset dir="${core_test.classes.dir}" excludes="org/eclipse/persistence/testing/framework/**/*.class"/>
</jar>
</target>
<!-- Translates the login information in the resources into the run directory. -->
<target name="process-resource">
<!-- fail message="Cannot find jdbc driver: '${jdbc.driver.jar}'." unless="jdbc.jar.exist"/ -->
<!-- fail message="Cannot find tools library: '${tools.lib}'." unless="tools.jar.exist"/ -->
<mkdir dir="${core_test.run.dir}"/>
<filter token="dbUser" value="${db.user}"/>
<filter token="dbPassword" value="${db.pwd}"/>
<filter token="driverClass" value="${db.driver}"/>
<filter token="dbURL" value="${db.url}"/>
<filter token="loglevel" value="${logging.level}"/>
<filter token="boolvalue" value="${logging.boolvalue}"/>
<filter token="dbPlatform" value="${db.platform}"/>
<echo message="Setup filtering values:"/>
<echo message="dbUser: '${db.user}'"/>
<echo message="dbPassword: ********"/>
<echo message="driverClass: '${db.driver}'"/>
<echo message="dbURL '${db.url}'"/>
<echo message="loglevel: '${logging.level}'"/>
<echo message="boolvalue: '${logging.boolvalue}'"/>
<echo message="dbPlatform: '${db.platform}'"/>
<echo message=" "/>
<echo message="Filter copying Resources (all but below) (default encoding):"/>
<echo message=" from '${core_test.resource.dir}'"/>
<echo message=" to '${core_test.run.dir}'"/>
<copy todir="${core_test.run.dir}" filtering="true" overwrite="true">
<fileset dir="${core_test.resource.dir}"
excludes="**/Employee_utf16.xml, **/NLSJapaneseMWIntegrationTestEmployeeProject.xml"/>
</copy>
<echo message="Filter copying Resources '**/Employee_utf16.xml' (UTF-16 encoding)"/>
<echo message=" from '${core_test.resource.dir}'"/>
<echo message=" to '${core_test.run.dir}'"/>
<copy todir="${core_test.run.dir}" filtering="true" overwrite="true" encoding="UTF-16">
<fileset dir="${core_test.resource.dir}" includes="**/Employee_utf16.xml"/>
</copy>
<echo message="Filter copying Resources '**/NLSJapaneseMWIntegrationTestEmployeeProject.xml' (Shift_JIS encoding)"/>
<echo message=" from '${core_test.resource.dir}'"/>
<echo message=" to '${core_test.run.dir}'"/>
<copy todir="${core_test.run.dir}" filtering="true" overwrite="true" encoding="Shift_JIS">
<fileset dir="${core_test.resource.dir}" includes="**/NLSJapaneseMWIntegrationTestEmployeeProject.xml"/>
</copy>
</target>
<!-- Testing -->
<!-- Test target to initialize a clean database (needed before a nighlty run of the LRG or a continuous build SRG run) -->
<target name="clear-database">
<antcall target="run-test" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.ClearDatabaseSchemaTest"/>
</antcall>
</target>
<!-- Default test target, runs test.class from test.properties (default is LRG). -->
<target name="test">
<antcall target="run-test" inheritRefs="true">
<param name="TEST_CLASS" value="${test.class}"/>
</antcall>
</target>
<!-- Runs SRG (SRGTestModel). -->
<target name="test-srg">
<antcall target="run-test" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.SRGTestModel"/>
</antcall>
</target>
<!-- Runs non-LRG tests -->
<target name="test-non-lrg">
<!-- Requires remote config.
The following JVM arguments must be set.
-Djava.naming.factory.initial=com.sun.jndi.cosnaming.CNCtxFactory
-Djava.naming.provider.url=iiop://localhost:900
-Djava.security.policy=./java.policy.allpermissions
The follwing corba naming server must also be started on the computer.
<java_home>/bin/tnameserv.exe
-->
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.remote.RMIRemoteModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.remote.rmi.IIOP.RMIIIOPRemoteModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.remote.suncorba.SunCORBARemoteModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.sessionbroker.RMISessionBrokerRemoteModel"/>
</antcall>
<!-- Requires user "scott" unlocked and granted special privileges on oracle database -->
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.feature.NativeModeCreatorTestModel"/>
</antcall>
<!-- Requires usage of Japanese machine and database. -->
<!--antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.nls.japanese.NLSMappingWorkbenchIntegrationTestModel"/>
</antcall-->
<!-- Requires specific LAB databases. -->
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.sessionbroker.BrokerTestModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.sessionbroker.MultipleClientBrokersTestModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.sessionbroker.ServerBrokerTestModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.distributedservers.DistributedSessionBrokerServersModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.distributedservers.rcm.RCMDistributedServersModel"/>
</antcall>
<!-- Can take a long time, can deadlock. -->
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.clientserver.ClientServerTestModel"/>
</antcall>
<!--PLSQL -->
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.plsql.PLSQLTestModel"/>
</antcall>
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.plsql.PLSQLXMLTestModel"/>
</antcall>
</target>
<!-- Runs LRG (TestRunModel). -->
<target name="test-lrg">
<antcall target="run-test" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.TestRunModel"/>
</antcall>
</target>
<!-- Prompt runner test target, runs test.class from test.properties (default is LRG). -->
<target name="test-prompt">
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="${test.class}"/>
</antcall>
</target>
<!-- Runs performance tests. -->
<target name="test-performance">
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.performance.PerformanceTestModel"/>
</antcall>
</target>
<!-- Runs concurrency tests. -->
<target name="test-concurrency">
<antcall target="run-test-prompt" inheritRefs="true">
<param name="TEST_CLASS" value="org.eclipse.persistence.testing.tests.performance.ConcurrencyComparisonTestModel"/>
</antcall>
</target>
<!-- Launches the testing browser -->
<target name="test-browser" depends="init_paths, process-resource">
<echo>Running test browser</echo>
<mkdir dir="${core_test.run.dir}"/>
<mkdir dir="${core_test.report.dir}"/>
<java classname="org.eclipse.persistence.testing.framework.ui.TestingBrowserFrame"
fork="true"
maxmemory="512m"
failonerror="false"
dir="${core_test.run.dir}">
<jvmarg value="-Declipselink.logging.level=${logging.level}"/>
<jvmarg value="${test.security-manager}"/>
<jvmarg value="${test.security-manager.policy}"/>
<jvmarg value="-Djava.naming.factory.initial=com.sun.jndi.cosnaming.CNCtxFactory"/>
<jvmarg line="${additional.jvmargs}"/>
<classpath>
<path refid="core_test.run.path"/>
</classpath>
</java>
</target>
<!-- Generic target for running tests. -->
<target name="run-test" depends="init_paths, process-resource">
<echo>Running test on ${db.url}</echo>
<mkdir dir="${core_test.run.dir}"/>
<mkdir dir="${core_test.report.dir}"/>
<!-- 282012: On a 64-bit JVM - The XML processing at the end of the testing requires at least 1536 -->
<!-- Note: on a legacy XP OS with 4GB ram - the max is 1536 - use of 2048 will cause [junit] [WARN ] Unable to acquire some virtual address space - reduced from 2048 to 1908MB. -->
<junit printsummary="yes" failureproperty="junit.failed" fork="yes" forkmode="once" showoutput="true" maxmemory="${max.heap.memory}" dir="${core_test.run.dir}">
<jvmarg value="-Declipselink.logging.level=${logging.level}"/>
<jvmarg value="-Ddb.driver=${db.driver}"/>
<jvmarg value="-Ddb.url=${db.url}"/>
<jvmarg value="-Ddb.user=${db.user}"/>
<jvmarg value="-Ddb.pwd=${db.pwd}"/>
<jvmarg value="-Ddb.platform=${db.platform}"/>
<jvmarg line="${additional.jvmargs}"/>
<jvmarg value="${test.security-manager}"/>
<jvmarg value="${test.security-manager.policy}"/>
<classpath>
<path refid="core_test.run.path"/>
</classpath>
<formatter type="xml"/>
<test name="${TEST_CLASS}" haltonfailure="no" outfile="${report.dir}/test-results">
</test>
</junit>
<junitreport todir="${core_test.report.dir}">
<fileset dir="${core_test.report.dir}">
<include name="test-results.xml"/>
</fileset>
<report format="noframes" todir="${core_test.report.dir}"/>
</junitreport>
<!-- fail message="Some of the junit tests failed. See the ${report.dir}/junit-noframes.html file for details." if="junit.failed"/ -->
</target>
<!-- Runs the test using the PromptTestRunner -->
<target name="run-test-prompt" depends="init_paths, process-resource">
<condition property="jvmarg.performance.baseline.version" value="-Dtoplink.loadbuild.baseline-version=${performance.baseline.version}">
<isset property="performance.baseline.version"/>
</condition>
<condition property="jvmarg.performance.baseline.version" value="-Ddummy=dummy">
<not>
<isset property="performance.baseline.version"/>
</not>
</condition>
<echo>Running test on ${db.url}</echo>
<mkdir dir="${core_test.run.dir}"/>
<mkdir dir="${core_test.report.dir}"/>
<java classname="org.eclipse.persistence.testing.framework.PromptTestRunner"
fork="true"
maxmemory="512m"
failonerror="false"
dir="${core_test.run.dir}">
<jvmarg value="${jvmarg.performance.baseline.version}"/>
<jvmarg value="-Declipselink.logging.level=${logging.level}"/>
<jvmarg value="-Ddb.driver=${db.driver}"/>
<jvmarg value="-Ddb.url=${db.url}"/>
<jvmarg value="-Ddb.user=${db.user}"/>
<jvmarg value="-Ddb.pwd=${db.pwd}"/>
<jvmarg value="-Ddb.platform=${db.platform}"/>
<jvmarg value="${test.security-manager}"/>
<jvmarg value="${test.security-manager.policy}"/>
<jvmarg value="-Djava.naming.factory.initial=com.sun.jndi.cosnaming.CNCtxFactory"/>
<jvmarg line="${additional.jvmargs}"/>
<arg value="testmodel=${TEST_CLASS}" />
<arg value="regressionlog=${core_test.report.dir}/test.log" />
<arg value="saveresults=${should.save.results}" />
<classpath>
<path refid="core_test.run.path"/>
</classpath>
</java>
</target>
<!-- Execute this target on non-Oracle database platforms only, because a test requires no Oracle JDBC jar in the classpath-->
<target name="test-ClassPathTestModel" depends="init_paths, process-resource">
<echo>Running test on ${db.url}</echo>
<mkdir dir="${core_test.run.dir}"/>
<mkdir dir="${core_test.report.dir}"/>
<java classname="org.eclipse.persistence.testing.framework.PromptTestRunner"
fork="true"
maxmemory="512m"
failonerror="false"
dir="${core_test.run.dir}">
<jvmarg value="-Declipselink.logging.level=${logging.level}"/>
<jvmarg value="-Ddb.driver=${db.driver}"/>
<jvmarg value="-Ddb.url=${db.url}"/>
<jvmarg value="-Ddb.user=${db.user}"/>
<jvmarg value="-Ddb.pwd=${db.pwd}"/>
<jvmarg value="-Ddb.platform=${db.platform}"/>
<jvmarg value=""/>
<jvmarg value="${test.security-manager}"/>
<jvmarg value="${test.security-manager.policy}"/>
<jvmarg line="${additional.jvmargs}"/>
<arg value="testmodel=org.eclipse.persistence.testing.tests.classpath.ClassPathTestModel" />
<arg value="regressionlog=${core_test.report.dir}/test.log" />
<arg value="createdbconnection=false" />
<arg value="saveresults=true" />
<classpath>
<path refid="core_test.compile.without.connector.path"/>
<path refid="core_test.runtime.only.path"/>
</classpath>
</java>
</target>
</project>