<?xml version="1.0"?>

<!--
* Copyright (c) 2003 Sun Microsystems, Inc. All  Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, 
* this list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may 
* be used to endorse or promote products derived from this software without 
* specific prior written permission.
* 
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS
* LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
* IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT
* OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
* PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use in the
* design, construction, operation or maintenance of any nuclear facility.
-->

<project name="JOALTest" basedir="." default="all">

    <description>JUNIT Tests JOAL</description>

    <property name="gluegen.basename" value="gluegen" /> <!-- if differs, ie jenkins jobname, must be set properly first -->
    <property name="joal.basename" value="joal" /> <!-- if differs, ie jenkins jobname, must be set properly first -->
    <echo message="gluegen.basename: ${gluegen.basename}"/>
    <echo message="joal.basename: ${joal.basename}"/>

    <property name="ant-contrib.jar"  value="${gluegen.root}/make/lib/ant-contrib-1.0b3.jar" />

    <taskdef resource="net/sf/antcontrib/antlib.xml">
      <classpath> <pathelement location="${ant-contrib.jar}"/> </classpath>
    </taskdef>

    <import file="${gluegen.root}/make/jogamp-env.xml" />
    <import file="${gluegen.root}/make/gluegen-cpptasks.xml" />

    <target name="declare.common" depends="jogamp.env.init, gluegen.cpptasks.detect.os">
        <property name="project.root"         value=".." />
        <property name="build"                value="${project.root}/${rootrel.build}" />

        <property name="rootrel.src.test"     value="src/test" />
        <property name="src.test"             value="${project.root}/${rootrel.src.test}" />

        <property name="results.test"         value="${build}/test/results" />
        <property name="build.test"           value="${build}/test/build" />
        <property name="obj.test"             value="${build.test}/obj"/>

        <property name="classes.test"         value="${build.test}/classes" />
        <property name="classes.test.path"    location="${classes.test}"/> <!-- absolute path -->

        <property name="java.dir.test"        value="com/jogamp/openal/test"/>
        <property name="java.part.test"       value="${java.dir.test}/**"/>
        <property name="java.dir.junit"       value="${java.dir.test}/junit"/>
        <property name="java.dir.manual"      value="${java.dir.test}/manual"/>

        <property name="obj.all.paths"        value="${gluegen.build}/obj${path.separator}${obj}${path.separator}lib/${os.and.arch}"/>
        <property name="classpath.test"       value="${junit.jar}${path.separator}${gluegen-rt.jar}${path.separator}${build}/joal.jar${path.separator}${build}/joal-test.jar"/>
        <property name="classpath.test.remote" value="${junit.jar}${path.separator}${env.TARGET_ANT_HOME}/lib/ant.jar${path.separator}${env.TARGET_ANT_HOME}/lib/ant-junit.jar${path.separator}${gluegen-rt.jar}${path.separator}${build}/joal.jar${path.separator}${build}/joal-test.jar"/>

        <property name="test.archive.name"    value="${archive.name}-test-results-${build.node.name}"/>

        <property name="batchtest.timeout"    value="1800000"/> <!-- 30 min -->

        <mkdir dir="${classes.test}"/>
    </target>

    <target name="test.compile" depends="declare.common">
        <!-- Clean the results -->
        <delete quiet="true">
            <fileset dir="${results.test}" includes="**"/>
            <fileset file="${build}/${test.archive.name}.7z"/>
        </delete>
        <mkdir dir="${results.test}"/>
    
        <javac destdir="${classes.test}" 
               includeantruntime="false"
               srcdir="${src.test}" 
               classpath="${gluegen-rt.jar};${build}/joal.jar;${junit.jar}"
               memoryMaximumSize="${javac.memorymax}"
               encoding="UTF-8"
               source="${target.sourcelevel}" 
               target="${target.targetlevel}" 
               bootclasspath="${target.rt.jar}"
               debug="${javacdebug}" debuglevel="${javacdebuglevel}"/>
        <copy todir="${classes.test}">
            <fileset dir="${src.test}" includes="**/*.wav"/>
        </copy>
        <jar destfile="${build}/joal-test.jar">
            <fileset dir="${classes.test}">
              <include name="**" />
            </fileset>
        </jar>
    </target>
    
    <target name="clean">
        <delete dir="${build.test}"/>
    </target>
    
    <target name="junit.run.local" depends="test.compile" unless="isCrosscompilation">
        <junit forkmode="perTest" showoutput="true" fork="true" haltonerror="off" includeAntRuntime="true">
            <env key="${system.env.library.path}" path="${obj.all.paths}"/>
            <jvmarg value="${jvmDataModel.arg}"/>
            <jvmarg value="-Djava.library.path=${obj.all.paths}"/>
            <!--
            <jvmarg value="-Djogamp.debug=all"/>
            <jvmarg value="-Djogamp.debug.NativeLibrary=true"/>
            <jvmarg value="-Djogamp.debug.NativeLibrary.Lookup=true"/>
            <jvmarg value="-Djogamp.debug.ProcAddressHelper=true"/> -->
            <jvmarg value="-Djoal.debug.Factory"/>
            <batchtest todir="${results.test}">
                <fileset dir="${classes.test}">
                    <include name="${java.dir.junit}/**/*Test*"/>
                </fileset>
                <formatter usefile="false" type="plain"/>
                <formatter usefile="true" type="xml"/>
            </batchtest>
            <classpath>
                <path path="${classpath.test}"/>
            </classpath>
        </junit>
    </target>
    
    <target name="test.manual.run" depends="test.compile">
        <for param="test.class.path.m" keepgoing="true">
            <!-- results in absolute path -->
            <fileset dir="${classes.test}">
                <include name="${java.dir.manual}/**/*Test*"/>
                <exclude name="**/*$$*"/>
            </fileset>
          <sequential>
            <var name="test.class.path" unset="true"/>
            <property name="test.class.path" basedir="${classes.test}" relative="true" location="@{test.class.path.m}"/>
            <var name="test.class.fqn" unset="true"/>
            <pathconvert property="test.class.fqn">
              <fileset file="${classes.test}${file.separator}${test.class.path}"/>
              <chainedmapper>
                  <globmapper    from="${classes.test.path}${file.separator}*" to="*"/> <!-- rel. -->
                  <packagemapper from="*.class"           to="*"/> <!-- FQCN -->
              </chainedmapper>
            </pathconvert>
            <var name="test.class.result.file" value="${results.test}/TEST-${test.class.fqn}.log"/>
            <echo message="Testing ${test.class.fqn} -- ${test.class.result.file}"/>
            <apply dir="." executable="${java.home}/bin/java" 
                 parallel="false" 
                 timeout="${batchtest.timeout}"
                 vmlauncher="false"
                 relative="true"
                 failonerror="false"
                 output="${test.class.result.file}">
                <env key="${system.env.library.path}" path="${obj.all.paths}"/>
                <env key="CLASSPATH" value="${classpath.test}"/>
                <arg line="${jvmDataModel.arg}"/>
                <arg value="-Djava.library.path=${obj.all.paths}"/>
                <!--
                <arg line="-Djogamp.debug=all"/>
                <arg line="-Djogamp.debug.NativeLibrary=true"/>
                <arg line="-Djogamp.debug.NativeLibrary.Lookup=true"/>
                <arg line="-Djogamp.debug.ProcAddressHelper=true"/> -->
                <arg line="-Djoal.debug.Factory"/>
                <srcfile/>
                <mappedresources>
                    <fileset dir="${classes.test}" includes="${test.class.path}"/>
                    <packagemapper from="*.class" to="*"/>
                </mappedresources>
            </apply>
          </sequential>
        </for>
    </target>

    <target name="junit.run.remote.ssh" if="isCrosscompilation" unless="isAndroid">
        <echo message="#! /bin/sh${line.separator}" append="false" file="${build.test}/targetcommand.sh" />
        <echo message="${line.separator}
rsync -av --delete --delete-after --delete-excluded \${line.separator}
      --exclude 'build-x86*/' --exclude 'build-linux-x*/' --exclude 'build-android*/' --exclude 'build-win*/' --exclude 'build-mac*/' \${line.separator}
      --exclude 'classes/' --exclude 'src/' --exclude '.git/' --exclude '*-java-src.zip' \${line.separator}
      ${env.HOST_UID}@${env.HOST_IP}::${env.HOST_RSYNC_ROOT}/${joal.basename} ${env.TARGET_ROOT} ${line.separator}
cd ${env.TARGET_ROOT}/${joal.basename}/${env.NODE_LABEL}/make ${line.separator}
" append="true" file="${build.test}/targetcommand.sh" />

        <for param="test.class.path.m" keepgoing="true">
            <!-- results in absolute path -->
            <fileset dir="${classes.test}">
                <include name="${java.dir.junit}/**/*Test*"/>
                <exclude name="**/*$$*"/>
            </fileset>
          <sequential>
            <var name="test.class.path" unset="true"/>
            <property name="test.class.path" basedir="${classes.test}" relative="true" location="@{test.class.path.m}"/>
            <var name="test.class.fqn" unset="true"/>
            <pathconvert property="test.class.fqn">
              <fileset file="${classes.test}${file.separator}${test.class.path}"/>
              <chainedmapper>
                  <globmapper    from="${classes.test.path}${file.separator}*" to="*"/> <!-- rel. -->
                  <packagemapper from="*.class"           to="*"/> <!-- FQCN -->
              </chainedmapper>
            </pathconvert>
            <var name="test.class.result.file" value="${results.test}/TEST-${test.class.fqn}.xml"/>
            <echo message="Testing ${test.class.fqn} -- ${test.class.result.file}"/>
            <echo message="${line.separator}
export DISPLAY=:0.0${line.separator}
java \${line.separator}
${junit.run.arg0}\${line.separator}
${junit.run.arg1}\${line.separator}
${jvmDataModel.arg}\${line.separator}
-cp ${classpath.test.remote}\${line.separator}
org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner \${line.separator}
${test.class.fqn} \${line.separator}
filtertrace=true \${line.separator}
haltOnError=false \${line.separator}
haltOnFailure=false \${line.separator}
showoutput=true \${line.separator}
outputtoformatters=true \${line.separator}
logfailedtests=true \${line.separator}
logtestlistenerevents=true \${line.separator}
formatter=org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter \${line.separator}
formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,${test.class.result.file} ${line.separator}
${line.separator}
" append="true" file="${build.test}/targetcommand.sh" />
          </sequential>
        </for>
        <exec dir="." executable="sh" logError="true" failonerror="true" failifexecutionfails="true">
            <arg line='-x -c "
            chmod 0755 ${build.test}/targetcommand.sh ;
            scp ${build.test}/targetcommand.sh ${env.TARGET_UID}@${env.TARGET_IP}:${env.TARGET_ROOT}/joal-targetcommand.sh ;
            ssh -x ${env.TARGET_UID}@${env.TARGET_IP} ${env.TARGET_ROOT}/joal-targetcommand.sh ;
            scp -pr ${env.TARGET_UID}@${env.TARGET_IP}:${env.TARGET_ROOT}/${joal.basename}/${env.NODE_LABEL}/make/${results.test}/* ${results.test}/ "'/>
        </exec>
    </target>

    <target name="junit.run.remote.adb" if="isAndroidARMv7">
        <echo message="#! /system/bin/sh${line.separator}" append="false" file="${build.test}/targetcommand.sh" />
        <echo message="${line.separator}
rsync -av --delete --delete-after --delete-excluded \${line.separator}
      --exclude 'build-x86*/' --exclude 'build-linux*/' --exclude 'build-win*/' --exclude 'build-mac*/' \${line.separator}
      --exclude 'classes/' --exclude 'src/' --exclude '.git/' --exclude '*-java-src.zip' \${line.separator}
      ${env.HOST_UID}@${env.HOST_IP}::${env.HOST_RSYNC_ROOT}/${joal.basename} ${env.TARGET_ROOT} ${line.separator}
cd ${env.TARGET_ROOT}/${joal.basename}/${env.NODE_LABEL}/make ${line.separator}
export ${system.env.library.path}=/system/lib:${env.TARGET_ROOT}/${gluegen.basename}/${rootrel.build}/obj:${env.TARGET_ROOT}/${gluegen.basename}/${rootrel.build}/test/build/natives ${line.separator}
export BOOTCLASSPATH=/system/framework/core.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/android.policy.jar:/system/framework/services.jar ${line.separator}
" append="true" file="${build.test}/targetcommand.sh" />

        <for param="test.class.path.m" keepgoing="true">
            <!-- results in absolute path -->
            <fileset dir="${build_t.java}">
                <include name="${test.junit.rel}/**/*Test*"/>
                <exclude name="**/*$$*"/>
            </fileset>
          <sequential>
            <var name="test.class.path" unset="true"/>
            <property name="test.class.path" basedir="${build_t.java}" relative="true" location="@{test.class.path.m}"/>
            <var name="test.class.fqn" unset="true"/>
            <pathconvert property="test.class.fqn">
              <fileset file="${build_t.java}${file.separator}${test.class.path}"/>
              <chainedmapper>
                  <globmapper    from="${build_t.java.path}${file.separator}*" to="*"/> <!-- rel. -->
                  <packagemapper from="*.class"           to="*"/> <!-- FQCN -->
              </chainedmapper>
            </pathconvert>
            <var name="test.class.result.file" value="${results}/TEST-${test.class.fqn}.xml"/>
            <echo message="Testing ${test.class.fqn} -- ${test.class.result.file}"/>
            <echo message="${line.separator}
dalvikvm \${line.separator}
-Xjnigreflimit:2000 \${line.separator}
-cp ${junit.run.remote.apks} \${line.separator}
-Dgluegen.root=${gluegen.root} \${line.separator}
-Drootrel.build=${rootrel.build} \${line.separator}
com.android.internal.util.WithFramework \${line.separator}
org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner \${line.separator}
${test.class.fqn} \${line.separator}
filtertrace=true \${line.separator}
haltOnError=false \${line.separator}
haltOnFailure=false \${line.separator}
showoutput=true \${line.separator}
outputtoformatters=true \${line.separator}
logfailedtests=true \${line.separator}
logtestlistenerevents=true \${line.separator}
formatter=org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter \${line.separator}
formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,${test.class.result.file} ${line.separator}
${line.separator}
" append="true" file="${build_t}/targetcommand.sh" />
          </sequential>
        </for>
        <exec dir="." executable="sh" logError="true" failonerror="true" failifexecutionfails="true">
            <arg line='-x -c "
            chmod 0755 ${build_t}/targetcommand.sh ;
            adb push ${build_t}/targetcommand.sh ${env.TARGET_ROOT}/joal-targetcommand.sh ;
            adb shell ${env.TARGET_ROOT}/joal-targetcommand.sh ;
            adb pull ${env.TARGET_ROOT}/${joal.basename}/${env.NODE_LABEL}/make/${results}/ ${results}/ "'/>
        </exec>
    </target>

    <target name="junit.run.tests" depends="junit.run.local, junit.run.remote.ssh"/>

    <target name="junit.run.if.enabled" unless="junit.is.disabled">
        <antcall target="junit.run.tests"      inheritRefs="true" inheritAll="true"/>
    </target>
    <target name="junit.run.if.disabled" if="junit.is.disabled">
        <copy todir="${results.test}" file="${gluegen.root}/make/lib/TEST-com.jogamp.junit.DisabledTest.xml"/>
    </target>

    <target name="junit.run" depends="declare.common,junit.run.if.enabled, junit.run.if.disabled">
        <antcall target="test-zip-archive" inheritRefs="true" inheritAll="true"/>
    </target>

    <target name="test.auto.run" depends="junit.run"/>

    <!-- updates / create the test results zip file -->
    <target name="test-zip-archive" depends="declare.common">
        <archive.7z destfile="${build}/${test.archive.name}.7z"
                    basedir="${results.test}" 
                    includes="**" />
    </target>

</project>