releng.wtpbuilder/distribution/wtp.tests/testScripts/library.xml

<?xml version="1.0"?>
<project name="Library" default="usage" basedir=".">

        <property environment="env" />

        <target name="usage">
                <echo message="Please refer to the testframework.html in org.eclipse.test for instructions on usage." />
        </target>

        <target name="init">
                <!--
                        Parameters:
                                (Mandatory)
                                data-dir                - the directory for Eclipse to write its data
                                plugin-name             - the name of the plugin to test
                                classname               - the name of the test class

                                (Optional - overrides defaults set in script)
                                vmargs                  - a string containing arguments to pass to the VM.
                                extraVMargs             - allows separate setting of VM args from separate caller.
                                timeout                 - overrides default test timeout value (in milliseconds).
                                test-output             - overrides default output file produced from test run.
                                plugin-path             - path to root of plug-in
                                useEclipseExe   - property setting forces test to launch via eclipse executable.
                                junit-report-output - output directory for junit reports produced for specified classname.
                -->

                <tstamp>
                <format property="TIMENOW" pattern="HHmmssSSSS"/>
            </tstamp>
                <!--property setting useEclipseExe launches tests using the eclipse executable-->
                <condition property="launchTarget" value="eclipse-test">
                        <isset property="useEclipseExe" />
                </condition>
                <!--default launch target for launching tests-->
                <property name="launchTarget" value="java-test" />
                <property name="formatter" value="org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter"/>
            <!--default heap sizes when running performance tests-->
            <condition property="vmargs" value=" -Xms256M -Xmx256M">
                        <equals arg1="${test.target}" arg2="performance" />
            </condition>
                <property name="extraVMargs" value=""/>
                <property name="plugin-path" value="" />
                <property name="timeout" value="7200000" />
                <property name="test-output" value="${eclipse-home}/${classname}.xml" />
                <property name="junit-report-output" value="${eclipse-home}/results" />
                <mkdir dir="${junit-report-output}"/>
        </target>

        <target name="core-test" description="Eclipse application used to launch HEADLESS plugin tests." depends="init">
                <antcall target="${launchTarget}">
                        <param name="application" value="org.eclipse.test.coretestapplication"/>
                </antcall>
        </target>

        <target name="ui-test" description="Eclipse application used to launch UI plugin tests." depends="init">
                <antcall target="${launchTarget}">
                        <param name="application" value="org.eclipse.test.uitestapplication"/>
                </antcall>
        </target>

        <target name="java-test">
                <!--default vm args-->
                <property name="vmargs" value=" -Xms40m -Xmx256m"/>

                <!--set default jvm to use for testing-->
                <property name="jvm" value="${java.home}/bin/java" />

                <echo message="Running ${classname}. Result file: ${junit-report-output}/${classname}.xml."/>

                <java fork="true" dir="." timeout="${timeout}" jvm="${jvm}" logError="true"
                        classname="org.eclipse.core.launcher.Main" output="${junit-report-output}/${classname}.txt">
                <classpath>
                        <fileset dir="${eclipse-home}/plugins">
                        <include name="org.eclipse.equinox.launcher_*.jar"/>
                        </fileset>
                </classpath>
                    <arg line="-application ${application}"/>
                    <arg line="-data ${data-dir}"/>
                    <arg line="formatter=${formatter},${test-output}"/>
                    <arg line="-testPluginName ${plugin-name}"/>
                    <arg line="-className ${classname}"/>
                    <arg line="-os ${os}"/>
                    <arg line="-ws ${ws}"/>
                    <arg line="-arch ${arch}"/>
                    <arg line="-consolelog"/>
                    <jvmarg line="${vmargs} ${extraVMargs}"/>
                    <sysproperty key="PLUGIN_PATH" value="${plugin-path}"/>
                </java>
                <antcall target="collect-results" />
        </target>

        <target name="eclipse-test" description="Runs the specified classname as a plug-in test.">
                <property name="vmargs" value="-Xms256m -Xmx512m"/>

                <!--use -consolelog if launching a headless test-->
                <condition property="consolelog" value="-consolelog">
                        <equals arg1="${application}" arg2="org.eclipse.test.coretestapplication"/>
                </condition>
                <property name="consolelog" value="" />

                <!--
                        vm selection priority:
                        1.  user-specified java executable via outer Ant property setting of "jvm".
                        2.  java executable on path.
                -->
                <condition property="test-vm" value="-vm ${jvm}">
                        <isset property="jvm" />
                </condition>
                <property name="test-vm" value="" />

                <!--ensure executable has execute permission-->
                <chmod file="${eclipse-home}/eclipse" perm="ugo+rx"/>


                <echo message="Running ${classname}" /> 
                <echo message="Result file: ${junit-report-output}/${classname}.xml."/>
                <echo message="DISPLAY: ${env.DISPLAY}" />
                <exec executable="${eclipse-home}/eclipse" dir="${eclipse-home}" timeout="${timeout}" logError="true" failonerror="false" >
                        <arg line="-data ${data-dir}"/>
                        <arg line="${test-vm}"/>
                        <arg line="-application ${application}"/>
                        <arg line="formatter=${formatter},${test-output}"/>
                        <arg line="-testPluginName ${plugin-name}"/>
                        <arg line="-className ${classname}"/>
                        <arg line="-nosplash"/>
                        <arg line="-suppressErrors"/>
                        <arg line="${consolelog}"/>
                        <arg line="-vmargs ${vmargs} ${extraVMargs} -DPLUGIN_PATH=${plugin-path}"/>
                        <env key="DISPLAY" value="${env.DISPLAY}"  />
                        <redirector output="${junit-report-output}/${classname}.output.txt" error="${junit-report-output}/${classname}.error.txt"/>
                        
                </exec>
                <antcall target="collect-results" />
        </target>

        <target name="collect-results">
                <dirname property="output-dir" file="${test-output}"/>
                <basename property="output-file-name" file="${test-output}"/>
                <junitreport todir="${junit-report-output}" tofile="${classname}.xml">
                        <fileset dir="${output-dir}">
                                <include name="${output-file-name}"/>
                        </fileset>
                </junitreport>

                <style style="${eclipse-home}/plugins/org.eclipse.test/JUNIT.XSL"
                        basedir="${junit-report-output}"
                        includes="${classname}.result.xml"
                        destdir="${junit-report-output}" />

                <!--save .log content and *.log content from configuration directory-->
                <concat destfile="${junit-report-output}/${classname}.log">
                        <fileset dir="${eclipse-home}" includes="${data-dir}/.metadata/*.log"/>
                        <fileset dir="${eclipse-home}" includes="configuration/*.log"/>
                </concat>
        </target>

        <target name="collect">
                <!--
                        This target can be used to aggragate test runs from multiple test suites into a single report.

                        Parameters to this target:
                        includes                - the names of the files to include
                        output-file             - the name of the output file to produce
                -->
                <junitreport todir="." tofile="${output-file}">
                        <fileset dir=".">
                                <include name="${includes}"/>
                        </fileset>
                </junitreport>
        </target>

        <target name="test-regressions">
                <!--
                        Parameters to this target:
                        oldfile                 - the name of the baseline XML file to test against
                        newfile                 - the name of the XML file containing most recent test results
                        outfile                 - the name of the file produced
                -->

                <echo message="Running Regression Tests"/>
                <property name="test-plugin-dir" value="${basedir}/fragments/org.eclipse.test"/>
                <property name="rt-stylesheet" value="${test-plugin-dir}/regression-test.xsl"/>
                <property name="rt-classname" value="org.eclipse.test.RegressionTest"/>

                <!-- Ensure that the file exists, and give sensible behaviour if not -->
                <style style="${rt-stylesheet}" in="${newfile}" out="${newfile}.tmp"/>
                <style style="${rt-stylesheet}" in="${oldfile}" out="${oldfile}.tmp"/>
                <java classname="${rt-classname}">
                        <classpath>
                                <pathelement location="${test-plugin-dir}/bin"/>
                        </classpath>
                        <arg value="${oldfile}.tmp"/>
                        <arg value="${newfile}.tmp"/>
                        <arg value="${outfile}"/>
                </java>

                <delete file="${oldfile}.tmp"/>
                <delete file="${newfile}.tmp"/>
        </target>

        <target name="notfiy">
                <!--
                        Parameters to this target:
                        infile  - the name of the file that contains the message body
                        address - the e-mail address to notify
                -->
                <echo message="Sending Notification"/>
                <property name="email-from" value="Eclipse Automated Test@oti.com"/>
                <property name="email-subject" value="Nightly Build Report"/>
                <property name="email-server" value="mail.ott.oti.com"/>

                <mail from="${email-from}" tolist="${address}"
          subject="${email-subject}" files="${infile}"
          mailhost="${email-server}"/>

        </target>

</project>