build.xml

<!-- Copyright (C) 2007 Google Inc.
  -
  - Licensed under the Apache License, Version 2.0 (the "License");
  - you may not use this file except in compliance with the License.
  - You may obtain a copy of the License at
  -
  -      http://www.apache.org/licenses/LICENSE-2.0
  -
  - Unless required by applicable law or agreed to in writing, software
  - distributed under the License is distributed on an "AS IS" BASIS,
  - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  - See the License for the specific language governing permissions and
  - limitations under the License.
 -->

<!--
  - For help, cd to the directory containing this file, run
  -    ant -p
  -
  - To build, cd to the directory containing this file, run
  -    ant <rulename>
  - and look for the output in ./ant-* directories.
  -
  - Valid values for <rulename> are:
  -   default    :  builds the plugin compiler (pluginc), tests, and docs
  -   benchmarks :  runs the benchmarks
  -   clean      :  wipes generated files
  -   demos      :  demo files
  -   docs       :  javadocs and rule docs
  -   jars       :  build the binary distribution
  -   pluginc    :  the plugin compiler
  -   runtests   :  runs the tests
  -
  - To run with assertions enabled, set the environment variable ANT_FLAGS="-ea"
 -->

<project name="caja" default="default" basedir="."
         xmlns:artifact="urn:maven-artifact-ant">
  <description>
  A subset of javascript that allow an application to securely embed plugins via
  a capability based security model.
  </description>
  <property name="build.sysclasspath" value="ignore" />

  <!-- Make the build reproducible/warning-free on newer versions of ant -->
  <property name="build.sysclasspath" value="ignore" />

  <!--== inputs ==-->
  <property name="src"         location="src"/>
  <property name="src.caja"    location="${src}/com/google/caja"/>
  <property name="tests"       location="tests"/>
  <property name="tests.caja"  location="${tests}/com/google/caja"/>
  <property name="test.filter" value="*Test"/>
  <property name="test.method.filter" value="*"/>
  <property name="third_party" location="third_party"/>
  <property name="demos"       location="${src.caja}/demos"/>
  <property name="precajolesrc" value="${third_party}/precajole"/>
  <!--== outputs ==-->
  <property name="reports"     location="ant-reports"/>  <!-- emma reports -->
  <property name="instr"       location="ant-instr"/>  <!-- instrumented src -->
  <property name="lib"         location="ant-lib"/>
  <property name="testlib"     location="ant-testlib"/>
  <property name="gwtlib"      location="ant-gwtlib"/>
  <property name="precajolelib" location="ant-precajolelib"/>
  <property name="lib.caja"    location="${lib}/com/google/caja"/>
  <property name="docs"        location="ant-docs"/>
  <property name="ruledocs"    location="${docs}/rules"/>
  <property name="javadocs"    location="${docs}/java"/>
  <property name="jars"        location="ant-jars"/>
  <property name="www"         location="ant-www"/>  <!-- demo files dir -->
  <!-- servlet dir - needs to be called "war" for GWT eclipse plugin/shell
    See http://code.google.com/webtoolkit/doc/1.6/ReleaseNotes_1_6.html
  -->
  <property name="war"         location="ant-war"/>
  <!-- TODO(ihab.awad): Find a way for the JUnit GWT tests to be happy with a
    WAR directory called, say, "ant-war". So far unsuccessful.
  -->
  <property name="gwt-war"     location="war"/>
  <property name="gwt.style"   value="OBFUSCATED"/>
  <property name="maven"       location="ant-maven"/>
  <property name="maven-repository-url" value="https://oss.sonatype.org/service/local/staging/deploy/maven2/" />
  <property name="maven-repository-id" value="sonatype-nexus-staging" />

  <!-- maven -->
  <property name="maven.ant.tasks.jar" value="third_party/ant/maven-ant-tasks-2.1.1.jar"/>

  <!--== classpaths ==-->

  <path id="classpath.main">
    <pathelement path="${lib}"/>
    <pathelement path="${jars}/htmlparser.jar"/>
    <pathelement path="${ant.home}/lib/ant.jar"/>
    <pathelement path="${third_party}/java/closure/compiler.jar"/>
    <pathelement path="${third_party}/java/guava/guava-r09.jar"/>
    <pathelement path="${third_party}/java/jaf/activation.jar"/>
    <pathelement path="${third_party}/java/jakarta_commons/commons-cli.jar"/>
    <pathelement path="${third_party}/java/jakarta_commons/commons-codec-1.4.jar"/>
    <pathelement path="${third_party}/java/jakarta_commons/commons-fileupload-1.2.1.jar"/>
    <pathelement path="${third_party}/java/jakarta_commons/commons-io-1.4.jar"/>
    <pathelement path="${third_party}/java/javamail/mail.jar"/>
    <pathelement path="${third_party}/java/jchardet/chardet.jar"/>
    <pathelement path="${third_party}/java/jetty/lib/jetty-util.jar"/>
    <pathelement path="${third_party}/java/jetty/lib/jetty.jar"/>
    <pathelement path="${third_party}/java/jsdk2.1/servlet.jar"/>
    <pathelement path="${third_party}/java/json_simple/json_simple.jar"/>
    <pathelement path="${third_party}/java/jsonml/jsonml.jar"/>
    <pathelement path="${third_party}/java/jsr305/jsr305.jar"/>
    <pathelement path="${third_party}/java/rhino/js.jar"/>
    <pathelement path="${third_party}/java/xerces/xercesImpl.jar"/>
  </path>

  <path id="classpath.gwt">
    <pathelement path="${gwtlib}"/>
    <pathelement path="${third_party}/java/appengine/lib/user/jsr107cache-1.1.jar"/>
    <pathelement path="${third_party}/java/appengine/lib/user/orm/geronimo-jpa_3.0_spec-1.1.1.jar"/>
    <pathelement path="${third_party}/java/appengine/lib/user/orm/jdo2-api-2.3-eb.jar"/>
    <pathelement path="${third_party}/java/gwt/gwt-api-checker.jar"/>
    <pathelement path="${third_party}/java/gwt/gwt-dev.jar"/>
    <pathelement path="${third_party}/java/gwt/gwt-servlet.jar"/>
    <pathelement path="${third_party}/java/gwt/gwt-user.jar"/>
  </path>

  <path id="classpath.tests">
    <!-- Must be first for coverage to work -->
    <pathelement path="${instr}/classes"/>
    <pathelement path="${precajolelib}/light"/>
    <pathelement path="${testlib}"/>
    <pathelement path="${third_party}/java/emma/emma.jar"/>
    <pathelement path="${third_party}/java/junit/junit.jar"/>
    <pathelement path="${third_party}/java/webdriver/selenium-server-standalone-2.24.1.jar"/>
    <path refid="classpath.main"/>
    <path refid="classpath.gwt"/>
  </path>

  <!--== Appengine tasks ==-->
  <import file="${third_party}/java/appengine/config/user/ant-macros.xml" />

  <taskdef resource="emma_ant.properties">
    <classpath>
      <pathelement path="${third_party}/java/emma/emma_ant.jar"/>
      <pathelement path="${third_party}/java/emma/emma.jar"/>
    </classpath>
  </taskdef>

  <taskdef name="junit"
   classname="org.apache.tools.ant.taskdefs.optional.junit.JUnitTask">
    <classpath>
      <pathelement path="${third_party}/java/apache_ant/ant-junit.jar"/>
      <pathelement path="${third_party}/java/junit/junit.jar"/>
    </classpath>
  </taskdef>

  <!--== rules.  Lowercase are public.  Uppercase are used internally. ==-->

  <target name="default" depends="jars"
   description="Builds the plugin compiler."/>

  <target name="all" depends="docs,jars,demos,runtests"
   description="Builds the plugin compiler, and documentation."/>

  <target name="clean"
   description="deletes all generated files leaving only sources">
    <delete dir="${reports}"/>
    <delete dir="${docs}"/>
    <delete dir="${instr}"/>
    <delete dir="${jars}"/>
    <delete dir="${lib}"/>
    <delete dir="${testlib}"/>
    <delete dir="${gwtlib}"/>
    <delete dir="${precajolelib}"/>
    <delete dir="${www}"/>
    <delete dir="${maven}"/>
    <delete dir="${war}"/>
    <delete dir="${gwt-war}"/>
    <delete dir="gwt-unitCache"/>
    <delete dir="${third_party}/java/htmlparser/lib"/>
  </target>

  <!-- TODO(felix8a): this is action at a distance; eliminate it -->
  <target name="dirs">
    <mkdir dir="${reports}"/>
    <mkdir dir="${docs}"/>
    <mkdir dir="${instr}"/>
    <mkdir dir="${jars}"/>
    <mkdir dir="${lib}"/>
    <mkdir dir="${gwtlib}"/>
    <mkdir dir="${precajolelib}"/>
    <mkdir dir="${www}"/>
    <mkdir dir="${war}"/>
    <mkdir dir="${gwt-war}"/>
    <mkdir dir="${maven}"/>
    <mkdir dir="${third_party}/java/htmlparser/lib"/>
  </target>

  <target name="brtest" description="Run just browser tests.">
    <antcall target="runtests">
      <param name="test.filter" value="*BrowserTest"/>
    </antcall>
  </target>

  <target name="brserve" description="Run just browser test server.">
    <antcall target="runtests">
      <param name="test.filter" value="GeneralBrowserTest"/>
      <param name="caja.BrowserTestCase.serverOnly" value="true"/>
    </antcall>
  </target>

  <target name="brserve+" description="... and a test browser.">
    <antcall target="runtests">
      <param name="test.filter" value="GeneralBrowserTest"/>
      <param name="caja.BrowserTestCase.startAndWait" value="true"/>
    </antcall>
  </target>

  <target name="runtests"
      depends="playground,AllTests,RuntestsRun,CacheTestSuccess"
      description="$ ant runtests [-Dtest.filter=My\*Test]"/>

  <property name="emma.coverage.out.file"
      value="${reports}/coverage/coverage.ec"/>
  <property name="emma.coverage.out.merge" value="false"/>

  <property name="testonly.user.language" value="tr"/>
  <property name="testonly.user.region" value="TR"/>

  <propertyset id="test.propertyset">
    <propertyref name="webdriver.firefox.bin"/>
    <propertyref prefix="caja.BrowserTestCase."/>
    <propertyref prefix="emma."/>
    <propertyref prefix="test."/>
    <propertyref prefix="testonly."/>
    <mapper type="glob" from="testonly.*" to="*"/>
  </propertyset>

  <target name="RuntestsRunAtoM" unless="emma.enabled">
    <junit printsummary="yes" fork="yes" forkmode="once" maxmemory="512m">
      <assertions><enable/></assertions>  <!-- ignored unless fork="yes" -->
      <classpath refid="classpath.tests"/>
      <formatter type="xml"/>
      <jvmarg line="${jvmarg}"/>
      <syspropertyset refid="test.propertyset"/>
      <batchtest todir="${reports}/tests">
        <fileset dir="${tests}">
          <and>
            <not><filename name="**/*BrowserTest.java"/></not>
            <filename name="**/${test.filter}.java"/>
            <filename regex="/[A-M]"/>
          </and>
        </fileset>
      </batchtest>
    </junit>
  </target>

  <target name="RuntestsRunNtoZ" unless="emma.enabled">
    <junit printsummary="yes" fork="yes" forkmode="once" maxmemory="512m">
      <assertions><enable/></assertions>  <!-- ignored unless fork="yes" -->
      <classpath refid="classpath.tests"/>
      <formatter type="xml"/>
      <jvmarg line="${jvmarg}"/>
      <syspropertyset refid="test.propertyset"/>
      <batchtest todir="${reports}/tests">
        <fileset dir="${tests}">
          <and>
            <not><filename name="**/*BrowserTest.java"/></not>
            <filename name="**/${test.filter}.java"/>
            <filename regex="/[N-Z]"/>
          </and>
        </fileset>
      </batchtest>
    </junit>
  </target>

  <target name="RuntestsRunBrowser" unless="emma.enabled">
    <junit printsummary="yes" fork="yes" forkmode="once" maxmemory="512m">
      <assertions><enable/></assertions>  <!-- ignored unless fork="yes" -->
      <classpath refid="classpath.tests"/>
      <formatter type="xml"/>
      <jvmarg line="${jvmarg}"/>
      <syspropertyset refid="test.propertyset"/>
      <batchtest todir="${reports}/tests">
        <fileset dir="${tests}">
          <and>
            <filename name="**/*BrowserTest.java"/>
            <filename name="**/${test.filter}.java"/>
          </and>
        </fileset>
      </batchtest>
    </junit>
  </target>

  <target name="RuntestsRunEmma" if="emma.enabled">
    <junit printsummary="yes" fork="yes" forkmode="once" maxmemory="512m">
      <assertions><enable/></assertions>  <!-- ignored unless fork="yes" -->
      <classpath refid="classpath.tests"/>
      <jvmarg line="${jvmarg}"/>
      <syspropertyset refid="test.propertyset"/>
      <test todir="${reports}/tests" name="com.google.caja.AllTests"/>
    </junit>
  </target>

  <target name="RuntestsCodeCheck">
    <exec executable="tools/codecheck.sh" failonerror="true"/>
  </target>

  <target name="RuntestsRun">
    <antcall target="RuntestsCodeCheck"/>
    <condition property="jvmarg"
     value="-Xdebug -Xmx2G -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=9999" else="">
      <isset property="test.debug"/>
    </condition>
    <!-- Instrument the compiled class files to gather code coverage stats -->
    <emma enabled="${emma.enabled}">
      <instr instrpath="${lib}" destdir="${instr}" mode="fullcopy"
       metadatafile="${reports}/coverage/metadata.em" merge="true">
        <filter value="${emma.filter},
                       -com.google.caja.tools.*,
                       -com.google.caja.parser.quasiliteral.*RuleDoclet"/>
      </instr>
    </emma>
    <mkdir dir="${reports}/tests"/>
    <property name="junit.threads" value="2"/>
    <parallel threadCount="${junit.threads}">
      <antcall target="RuntestsRunBrowser"/>
      <antcall target="RuntestsRunAtoM"/>
      <antcall target="RuntestsRunNtoZ"/>
      <antcall target="RuntestsRunEmma"/>
    </parallel>
    <summarize errorProperty="runtests.error"
     failureProperty="runtests.failure">
      <fileset dir="${reports}/tests">
        <include name="TEST-*.xml"/>
      </fileset>
    </summarize>
    <!-- Generate the code coverage report. -->
    <emma enabled="${emma.enabled}">
      <report sourcepath="${src}:${tests}" sort="+name"
       metrics="method:70,block:80,line:80,class:100">
        <fileset dir="${reports}/coverage">
          <include name="*.em" />
          <include name="*.ec" />
        </fileset>
        <html outfile="${reports}/coverage/index.html" encoding="UTF-8"/>
      </report>
    </emma>
    <!-- Generate the test results report. -->
    <junitreport todir="${reports}/tests">
      <fileset dir="${reports}/tests" includes="TEST-*.xml"/>
      <report format="frames" todir="${reports}/tests"
       styledir="${third_party}/ant/etc"/>
    </junitreport>
    <condition property="runtests.success">
      <and>
        <isfalse value="runtests.error"/>
        <isfalse value="runtests.failure"/>
      </and>
    </condition>
  </target>

  <target name="CacheOrFail">
    <!-- Capture conditions that if set invalidate caching of test results -->
    <condition property="runtests.shouldCache">
      <and>
        <istrue value="${runtests.success}"/>
        <equals arg1="${test.filter}" arg2="*Test"/>
        <isfalse value="${caja.BrowserTestCase.startAndWait}"/>
      </and>
    </condition>
    <fail message=
     "One or more tests failed. For details, see ${reports}/tests/index.html"
     if="runtests.error"/>
    <fail message=
     "One or more tests failed. For details, see ${reports}/tests/index.html"
     if="runtests.failure"/>
  </target>

  <target name="CacheTestSuccess" depends="CacheOrFail" if="runtests.shouldCache">
    <echo>
      Caching test results. If undesired, clear with "ant cleartestcache"
    </echo>
    <!-- Snapshot the change being tested to reduce rerunning tests on submit -->
    <exec output="${lib}/runtests.success.patch"
        executable="svn"
        failonerror="false"
        failifexecutionfails="false"
        dir=".">
      <arg value="diff"/>
    </exec>
  </target>

  <target name="cleartestcache">
    <delete file="${lib}/runtests.success.patch"></delete>
  </target>

  <target name="runbrowserstub" depends="AllTests">
    <java failonerror="false" fork="true"
     classname="com.google.caja.plugin.BrowserTestCaseStub">
      <classpath refid="classpath.tests"/>
    </java>
  </target>

  <target name="docs" description="Builds all Caja documentation."
   depends="javadocs,ruledocs,cajajsdocs"/>

  <target name="cajajsdocs">
    <mkdir dir="${docs}/cajajs"/>
    <xslt in="doc/cajajs/cajajs.xml"
          out="${docs}/cajajs/index.html"
          style="doc/cajajs/apidoc.xsl"/>
    <copy todir="${docs}/cajajs">
      <fileset dir="doc/cajajs">
        <include name="apidoc.css"/>
        <include name="apidoc.js"/>
      </fileset>
      <fileset dir="third_party/js/">
        <include name="prettify/**"/>
      </fileset>
    </copy>
  </target>

  <target name="JavadocsCheck">
    <uptodate property="javadocs.uptodate" targetfile="${jars}/pluginc-javadocs.jar">
      <srcfiles dir="${src}/com/google/caja" includes="*" />
      <srcfiles dir="${tests}/com/google/caja" includes="*" />
    </uptodate>
  </target>

  <target name="javadocs" depends="JavadocsCheck" unless="javadocs.uptodate">
    <mkdir dir="${javadocs}"/>
    <javadoc sourcepath="${src}:${tests}" destdir="${javadocs}" access="private"
     author="true"
     bottom="Copyright (C) 2008 Google Inc.&lt;br&gt;
             &lt;a href=&#34;http://www.apache.org/licenses/LICENSE-2.0&#34;&gt;
             Licensed under the Apache License, Version 2.0&lt;/a&gt;"
     docencoding="utf-8"
     packagenames="com/google/caja/*"
     classpathref="classpath.main"
     includenosourcepackages="true"
     linksource="yes"/>
    <!-- overview="${src}/overview.html" -->
    <jar destfile="${jars}/pluginc-javadocs.jar" basedir="${javadocs}"/>
  </target>

  <target name="ruledocs" depends="RuleDoclet"
      description="Caja rule documentation.">
    <mkdir dir="${ruledocs}"/>
    <ruledoclet output="html" outputdir="${ruledocs}"
     rewriter="com.google.caja.parser.quasiliteral.ES53Rewriter"/>
  </target>

  <target name="tools" depends="PluginCompiler">
    <!-- Now that we have the compiler, build ant task wrappers -->
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <include name="**/ancillary/linter/Linter.java"/>
      <include name="**/precajole/PrecajoleTask.java" />
      <include name="**/tools/*.java"/>
      <compilerarg line="-Xlint:deprecation"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>
    <!-- Copy supporting javascript to lib -->
    <copy todir="${lib}">
      <fileset dir="${third_party}">
        <include name="js/jqueryjs/runtest/env.js"/>
      </fileset>
      <fileset dir="${tests}">
        <include name="**/caja/plugin/console-stubs.js"/>
      </fileset>
    </copy>
    <taskdef name="transform" classname="com.google.caja.tools.TransformAntTask"
     classpathref="classpath.main" />
    <taskdef name="innocent" classname="com.google.caja.tools.InnocentAntTask"
     classpathref="classpath.main"/>
    <taskdef name="genrule" classname="com.google.caja.tools.GenRuleAntTask"
     classpathref="classpath.main"/>
    <taskdef name="precajole"
     classname="com.google.caja.precajole.PrecajoleTask"
     classpathref="classpath.main" />

    <!-- If testlib doesn't exist when summarize is defined, it's
         dropped from summarize's classpath, which means
         summarize won't be able to find test class files -->
    <mkdir dir="${testlib}"/>
    <taskdef name="summarize" classname="com.google.caja.tools.TestSummary"
     classpathref="classpath.tests" />

    <copy todir="${lib}">
      <fileset dir="${src}">
        <include name="**/caja/ancillary/**/*.js"/>
        <include name="**/caja/ancillary/**/*.json"/>
        <include name="**/caja/ancillary/**/*.txt"/>
        <include name="**/caja/ancillary/**/*.css"/>
        <include name="**/caja/ancillary/**/*.html"/>
        <include name="**/caja/ancillary/**/*.gif"/>
      </fileset>
    </copy>
  </target>

  <target name="pluginc" depends="tools"
   description="Build the plugin compiler and other main classes">
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <include name="com/google/caja/plugin/*Main.java"/>
      <!-- used by Closure Compiler JsonMLConversionTest -->
      <include name="com/google/caja/parser/js/JsonMLParser.java"/>
    </javac>
    <!-- Generate a schema of CSS properties for client side CSS validation. -->
    <copy todir="${lib}">
      <fileset dir="${src}">
        <include name="**/caja/lang/*/*.json"/>
      </fileset>
    </copy>
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <include name="**/caja/lang/css/CssPropertyPatterns.java"/>
      <include name="**/caja/lang/html/HtmlDefinitions.java"/>
    </javac>
    <genrule class="com.google.caja.lang.css.CssPropertyPatterns$Builder">
      <output file="${lib.caja}/plugin/css-defs.js"/>
      <input file="${src.caja}/lang/css/css-extensions.json"/>
      <depend file="${src.caja}/lang/css/css21.json"/>
      <depend file="${src.caja}/lang/css/css21-defs.json"/>
      <depend file="${src.caja}/lang/css/css21-whitelist.json"/>
      <depend file="${src.caja}/lang/css/css-extensions.json"/>
      <depend file="${src.caja}/lang/css/css-extensions-defs.json"/>
      <depend file="${src.caja}/lang/css/css-extensions-whitelist.json"/>
      <input file="${src.caja}/lang/css/css21-fns.json"/>
      <depend file="${src.caja}/lang/css/css21-fns-defs.json"/>
      <depend file="${src.caja}/lang/css/css21-fns-whitelist.json"/>
      <depend file="${src.caja}/lang/css/CssPropertyPatterns.java"/>
    </genrule>
    <genrule class="com.google.caja.lang.html.HtmlDefinitions$Builder">
      <output file="${lib.caja}/plugin/html4-defs.js"/>
      <input file="${src.caja}/lang/html/html4-elements-extensions.json"/>
      <depend file="${src.caja}/lang/html/html4-elements.json"/>
      <depend file="${src.caja}/lang/html/html4-elements-defs.json"/>
      <depend file="${src.caja}/lang/html/html4-elements-extensions-defs.json"/>
      <depend
       file="${src.caja}/lang/html/html4-elements-extensions-whitelist.json"/>
      <depend file="${src.caja}/lang/html/html4-elements-whitelist.json"/>
      <input file="${src.caja}/lang/html/html4-attributes-extensions.json"/>
      <depend file="${src.caja}/lang/html/html4-attributes.json"/>
      <depend file="${src.caja}/lang/html/html4-attributes-defs.json"/>
      <depend
       file="${src.caja}/lang/html/html4-attributes-extensions-defs.json"/>
      <depend file="${src.caja}/lang/html/html4-attributes-whitelist.json"/>
      <depend file="${src.caja}/lang/html/HtmlDefinitions.java"/>
    </genrule>
  </target>

  <target name="benchmarks" description="Runs benchmarks."
   depends="pluginc,jars">
    <copy todir="${lib.caja}/demos/benchmarks">
      <fileset dir="${third_party}/js/sunspider-benchmark/">
        <include name="v8-crypto.js"/>
        <include name="v8-earley-boyer.js"/>
        <include name="v8-raytrace.js"/>
        <include name="v8-richards.js"/>
        <include name="v8-deltablue.js"/>
      </fileset>
      <fileset dir="${third_party}/js/sunspider-benchmark/ubench">
        <include name="function-closure.js"/>
        <include name="function-correct-args.js"/>
        <include name="function-empty.js"/>
        <include name="function-excess-args.js"/>
        <include name="function-missing-args.js"/>
        <include name="function-sum.js"/>
        <include name="loop-empty-resolve.js"/>
        <include name="loop-empty.js"/>
        <include name="loop-sum.js"/>
      </fileset>
    </copy>
    <copy todir="${lib.caja}">
      <fileset dir="${src.caja}">
        <include name="es53.js"/>
      </fileset>
    </copy>
    <mkdir dir="${reports}/benchmarks"/>
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${tests}"/>
      <classpath refid="classpath.tests"/>
      <include name="**/caja/demos/benchmarks/*.java"/>
    </javac>
    <junit printsummary="yes" fork="yes" maxmemory="512m"
     errorProperty="benchmarks.error" failureProperty="benchmarks.failure">
      <assertions><enable/></assertions>  <!-- ignored unless fork="yes" -->
      <classpath refid="classpath.tests"/>
      <formatter type="xml" usefile="true"/>
      <test name="com.google.caja.demos.benchmarks.BenchmarkSize"
       todir="${reports}/benchmarks"/>
      <test name="com.google.caja.demos.benchmarks.BenchmarkRunner"
       todir="${reports}/benchmarks"/>
    </junit>
    <junitreport todir="${reports}/benchmarks">
      <fileset dir="${reports}/benchmarks" includes="TEST-*.xml"/>
      <report format="frames" todir="${reports}/benchmarks"
       styledir="${third_party}/ant/etc"/>
    </junitreport>
  </target>

  <target name="jars-no-src"
      depends="pluginc, MinifiedJs, CajolingServlet"
      description="Place all jars needed to run the cajoler under ${jars}">
    <copy todir="${jars}">
      <fileset dir="${third_party}/java/jakarta_commons">
        <include name="commons-cli.jar"/>
        <include name="commons-fileupload-1.2.1.jar"/>
        <include name="commons-io-1.4.jar"/>
        <include name="commons-codec-1.4.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/jaf">
        <include name="activation.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/javamail">
        <include name="mail.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/guava">
        <include name="guava-r09.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/json_simple">
        <include name="json_simple.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/jsdk2.1">
        <include name="servlet.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/rhino">
        <include name="js.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/jetty/lib">
        <include name="jetty.jar"/>
        <include name="jetty-util.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/jsonml">
        <include name="jsonml.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/xerces">
        <include name="xercesImpl.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/rhino">
        <include name="js.jar"/>
      </fileset>
    </copy>
    <jar destfile="${jars}/pluginc.jar">
      <manifest>
        <attribute name="Main-Class"
         value="com.google.caja.plugin.PluginCompilerMain"/>
      </manifest>
      <fileset dir="${lib}">
        <include name="com/google/caja/**"/>
        <include name="js/json_sans_eval/json_sans_eval.js"/>
      </fileset>
    </jar>
  </target>

  <target name="jars" depends="jars-no-src">
    <jar destfile="${jars}/pluginc-src.jar" basedir="${src}"/>
  </target>

  <macrodef name="JQueryTestCase">
    <attribute name="testcase" />
    <sequential>
      <copy file="${lib}/js/jqueryjs/test/index-template.html" tofile="${lib}/js/jqueryjs/test/@{testcase}-uncajoled.html" />
      <replace file="${lib}/js/jqueryjs/test/@{testcase}-uncajoled.html" value="@{testcase}">
        <replacetoken><![CDATA[@jquery-testcase@]]></replacetoken>
      </replace>
      <copy file="${lib}/js/jqueryjs/test/hostpage-template.html" tofile="${lib}/js/jqueryjs/test/@{testcase}.html" />
      <replace file="${lib}/js/jqueryjs/test/@{testcase}.html" value="@{testcase}">
        <replacetoken><![CDATA[@jquery-testcase@]]></replacetoken>
      </replace>
      <transform>
        <input file="${lib}/js/jqueryjs/test/@{testcase}-uncajoled.html" />
        <output file="${lib}/js/jqueryjs/test/@{testcase}-cajoled.js"
            onlyJsEmitted="true"
            language="caja"
            canLink="http://simon.incutio.com/archive/2003/03/25#getElementsBySelector \
                           http://www.google.com/ \
                           http://groups.google.com/ \
                           http://smin/ \
                           http://diveintomark.org/ \
                           http://www.yahoo.com/ \
                           http://simon.incutio.com/"
        />
  
        <depend file="${lib}/js/jqueryjs/test/data/ua.txt"/>
        <depend file="${lib}/js/jqueryjs/test/qunit/qunit/qunit.css"/>
        <depend file="${lib}/js/jqueryjs/test/data/testsuite.css"/>
        <depend file="${lib}/js/jqueryjs/test/data/testinit.js"/>
        <depend file="${lib}/js/jqueryjs/test/qunit/qunit/qunit.js"/>
        <depend file="${lib}/js/jqueryjs/test/data/testrunner.js"/>
        <depend file="${lib}/js/jqueryjs/dist/jquery.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/core.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/callbacks.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/deferred.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/support.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/data.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/queue.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/attributes.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/event.js"/>
        <depend file="${lib}/js/jqueryjs/src/sizzle/test/unit/selector.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/selector.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/traversing.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/manipulation.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/css.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/ajax.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/effects.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/offset.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/dimensions.js"/>
        <depend file="${lib}/js/jqueryjs/test/unit/exports.js"/>
      </transform>
    </sequential>
  </macrodef>

  <target name="jquery" depends="CajoledDomado">
    <!-- The root files of the Domita test cases are statically cajoled -->
    <copy todir="${lib}">
      <fileset dir="${third_party}">
        <include name="js/jqueryjs/**/*"/>
        <exclude name="**/*.jar"/>
      </fileset>
    </copy>
    <JQueryTestCase testcase="core" />
    <JQueryTestCase testcase="callbacks" />
    <JQueryTestCase testcase="deferred" />
    <JQueryTestCase testcase="support" />
    <JQueryTestCase testcase="data" />
    <JQueryTestCase testcase="queue" />
    <JQueryTestCase testcase="attributes" />
    <JQueryTestCase testcase="event" />
    <JQueryTestCase testcase="../../src/sizzle/test/unit/selector" />
    <JQueryTestCase testcase="selector" />
    <JQueryTestCase testcase="traversing" />
    <JQueryTestCase testcase="manipulation" />
    <JQueryTestCase testcase="css" />
    <JQueryTestCase testcase="ajax" />
    <JQueryTestCase testcase="effects" />
    <JQueryTestCase testcase="offset" />
    <JQueryTestCase testcase="dimensions" />
    <JQueryTestCase testcase="exports" />
    <copy todir="${war}/jquery">
      <fileset file="${lib}/js/jqueryjs/index.html" />
    </copy>
    <copy todir="${war}/jquery/test">
      <fileset dir="${lib}/js/jqueryjs/test/" />
    </copy>
    <copy todir="${war}/jquery/src">
      <fileset dir="${lib}/js/jqueryjs/src/" />
    </copy>
    <copy todir="${war}/jquery/dist">
      <fileset dir="${lib}/js/jqueryjs/dist/" />
    </copy>
  </target>

  <!-- Cajoles test resources that contain es53 to javascript. -->
  <target name="CajoledTests" depends="CajoledDomado">
    <property name="libplugin" location="${lib.caja}/plugin"/>

    <!-- Statically cajole some tests for caja.js testing -->
    <transform>
     <input file="${tests.caja}/plugin/es53-test-guest.js"/>
     <output file="${testlib}/com/google/caja/plugin/es53-test-guest.out.js"
             language="caja"/>
    </transform>
    <transform>
     <input file="${tests.caja}/plugin/es53-test-guest.html"/>
     <output file="${testlib}/com/google/caja/plugin/es53-test-guest.out.html"
             language="caja"/>
    </transform>
    <transform>
     <input file="${tests.caja}/plugin/es53-test-cajoled.js"/>
     <output file="${testlib}/com/google/caja/plugin/es53-test-cajoled.out.js"
             language="caja"/>
    </transform>

    <!-- These and other HTML and JS files are copied verbatim -->
    <copy todir="${testlib}">
      <fileset dir="${tests}" includes="**/*.html,**/*.js"/>
    </copy>

    <replace dir="${testlib}/com/google/caja/plugin"
        propertyFile="${lib.caja}/reporting/buildInfo.properties" >
      <replacefilter token="%VERSION%" property="svnVersion" />
      <include name="browser-test-case.js" />
      <include name="modules-test.html" />
    </replace>
  </target>

  <target name="CajoledDomado" depends="pluginc">
    <transform>
      <output file="${lib}/domado.jslint.stamp"
       language="jslint"/>
      <output file="${lib.caja}/plugin/domado.out.js"
       language="caja" renderer="pretty"/>
      <input file="${src.caja}/ses-promise.js"/>
      <input file="${src.caja}/plugin/unicode.js"/>
      <input file="${lib.caja}/plugin/css-defs.js"/>
      <input file="${lib.caja}/plugin/html4-defs.js"/>
      <input file="${src.caja}/plugin/html-sanitizer.js"/>
      <input file="${src.caja}/plugin/html-emitter.js"/>
      <input file="${src.caja}/plugin/csslexer.js"/>
      <input file="${src.caja}/plugin/sanitizecss.js"/>
      <input file="${src.caja}/plugin/cssparser.js"/>
      <input file="${src.caja}/plugin/bridal.js"/>
      <input file="${src.caja}/plugin/domado.js"/>
    </transform>
  </target>

  <target name="CajoledTamingMembrane" depends="pluginc">
    <transform>
      <output file="${lib.caja}/plugin/taming-membrane.out.js"
              language="caja" renderer="pretty"/>
        <input file="${src.caja}/plugin/taming-membrane.js"/>
    </transform>
  </target>

  <target name="CajoledTamingSchema" depends="pluginc">
    <transform>
        <output file="${lib.caja}/plugin/taming-schema.out.js"
                language="caja" renderer="pretty"/>
        <input file="${src.caja}/plugin/taming-schema.js"/>
    </transform>
  </target>

    <target name="MinifiedJs" depends="CajoledDomado,CajoledTamingMembrane,CajoledTamingSchema">
    <transform>
      <output file="${lib}/caja.jslint.stamp"
        language="jslint"/>
      <output file="${lib.caja}/plugin/caja-minified.js"
        language="closure"/>
      <input file="${lib.caja}/plugin/caja.js"/>
    </transform>
    <transform>
      <output file="${lib}/html-sanitizer.jslint.stamp"
        language="jslint"/>
      <output file="${lib.caja}/plugin/html-sanitizer-minified.js"
        language="closure"/>
      <output file="${lib.caja}/plugin/html-sanitizer-bundle.js"
        language="javascript" renderer="concat"/>
      <input file="${lib.caja}/plugin/html4-defs.js"/>
      <input file="${src.caja}/plugin/html-sanitizer.js"/>
    </transform>
    <transform>
      <output file="${lib}/html-css-sanitizer.jslint.js"
       language="jslint"/>
      <!-- TODO(felix8a): -closured doesn't work -->
      <output file="${lib.caja}/plugin/html-css-sanitizer-closured.js"
       language="closure"/>
      <output file="${lib.caja}/plugin/html-css-sanitizer-minified.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/plugin/html-css-sanitizer-bundle.js"
       language="javascript" renderer="concat"/>
      <input file="${lib.caja}/plugin/css-defs.js"/>
      <input file="${src.caja}/plugin/csslexer.js"/>
      <input file="${src.caja}/plugin/sanitizecss.js"/>
      <input file="${src.caja}/plugin/cssparser.js"/>
      <input file="${lib.caja}/plugin/html4-defs.js"/>
      <input file="${src.caja}/plugin/html-sanitizer.js"/>
    </transform>
    <transform>
      <output file="${lib}/es53-taming-frame.jslint.stamp"
       language="jslint"/>
      <!-- TODO(felix8a): closure cleanup
      <output file="${lib.caja}/plugin/es53-taming-frame.clo.js"
       language="closure"/>
      -->
      <output file="${lib.caja}/plugin/es53-taming-frame.opt.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/plugin/es53-taming-frame.js"
       language="javascript" renderer="concat"/>
      <input file="${src.caja}/plugin/caja-iframe-build-version.js"/>
      <input file="${third_party}/js/json_sans_eval/json_sans_eval.js"/>
      <input file="${src.caja}/es53.js"/>
      <input file="${src.caja}/plugin/capture-cajoled-module.js"/>
      <input file="${src.caja}/plugin/capture-domado.js"/>
      <input file="${lib.caja}/plugin/domado.out.js" jslint="false"/>
      <input file="${src.caja}/plugin/capture-taming-schema.js"/>
      <input file="${lib.caja}/plugin/taming-schema.out.js" jslint="false"/>
      <input file="${src.caja}/plugin/capture-taming-membrane.js"/>
      <input file="${lib.caja}/plugin/taming-membrane.out.js" jslint="false"/>
      <input file="${src.caja}/plugin/uri.js"/>
      <input file="${src.caja}/cajita-promise.js"/>
      <input file="${src.caja}/plugin/json-rest-transport.js"/>
      <input file="${src.caja}/plugin/cajoling-service-client.js"/>
      <input file="${src.caja}/plugin/taming-frame.js"/>
      <input file="${src.caja}/flash/caja-flash.js"/>
      <input file="${src.caja}/plugin/guest-manager.js"/>
      <input file="${src.caja}/plugin/es53-frame-group.js"/>
      <input file="${src.caja}/plugin/caja-iframe-done.js"/>
    </transform>
    <transform>
      <output file="${lib}/es53-guest-frame.jslint.stamp"
       language="jslint"/>
      <!-- TODO(felix8a): closure cleanup
      <output file="${lib.caja}/plugin/es53-guest-frame.clo.js"
       language="closure"/>
      -->
      <output file="${lib.caja}/plugin/es53-guest-frame.opt.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/plugin/es53-guest-frame.js"
       language="javascript" renderer="concat"/>
      <input file="${src.caja}/plugin/caja-iframe-build-version.js"/>
      <input file="${third_party}/js/json_sans_eval/json_sans_eval.js"/>
      <input file="${src.caja}/es53.js"/>
      <input file="${src.caja}/cajita-promise.js"/>
      <input file="${src.caja}/plugin/prepare-modules.js"/>
      <input file="${src.caja}/plugin/load-module.js"/>
      <input file="${src.caja}/plugin/caja-iframe-done.js"/>
    </transform>
    <transform>
      <output file="${lib}/initSES.jslint.stamp"
       language="jslint"/>
      <!-- TODO(felix8a): closure cleanup
      <output file="${lib.caja}/ses/initSES-closured.js"
       language="closure"/>
      -->
      <output file="${lib.caja}/ses/initSES-minified.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/ses/initSES.js"
       language="javascript" renderer="concat"/>
      <input file="${src.caja}/ses/logger.js"/>
      <input file="${src.caja}/ses/repairES5.js"/>
      <input file="${src.caja}/ses/WeakMap.js"/>
      <input file="${src.caja}/ses/StringMap.js"/>
      <input file="${src.caja}/ses/whitelist.js"/>
      <input file="${src.caja}/ses/atLeastFreeVarNames.js"/>
      <input file="${src.caja}/ses/startSES.js"/>
      <input file="${src.caja}/ses/hookupSES.js"/>
    </transform>
    <transform>
      <output file="${lib}/initSESPlus.jslint.stamp"
       language="jslint"/>
      <!-- TODO(felix8a): closure cleanup
      <output file="${lib.caja}/ses/initSESPlus-closured.js"
       language="closure"/>
      -->
      <output file="${lib.caja}/ses/initSESPlus-minified.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/ses/initSESPlus.js"
       language="javascript" renderer="concat"/>
      <input file="${src.caja}/ses/logger.js"/>
      <input file="${src.caja}/ses/repairES5.js"/>
      <input file="${src.caja}/ses/WeakMap.js"/>
      <input file="${src.caja}/ses/debug.js"/>
      <input file="${src.caja}/ses/StringMap.js"/>
      <input file="${src.caja}/ses/whitelist.js"/>
      <input file="${src.caja}/ses/atLeastFreeVarNames.js"/>
      <input file="${src.caja}/ses/startSES.js"/>
      <input file="${src.caja}/ses/ejectorsGuardsTrademarks.js"/>
      <input file="${src.caja}/ses/hookupSESPlus.js"/>
    </transform>
    <transform>
      <!-- ses-taming-frame: Used by caja.js when the browser is SES-capable.
      -->
      <output file="${lib}/ses-taming-frame.jslint.stamp"
       language="jslint"/>
      <!-- TODO(felix8a): closure cleanup
      <output file="${lib.caja}/plugin/ses-taming-frame.clo.js"
       language="closure"/>
      -->
      <output file="${lib.caja}/plugin/ses-taming-frame.opt.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/plugin/ses-taming-frame.js"
       language="javascript" renderer="concat"/>
      <input file="${src.caja}/plugin/caja-iframe-build-version.js"/>
      <input file="${third_party}/js/json_sans_eval/json_sans_eval.js"/>
      <input file="${src.caja}/plugin/ses-iframe-init.js"/>
      <input file="${lib.caja}/ses/initSESPlus.js" jslint="false"/>

      <input file="${src.caja}/plugin/unicode.js"/>
      <input file="${lib.caja}/plugin/css-defs.js"/>
      <input file="${lib.caja}/plugin/html4-defs.js"/>
      <input file="${src.caja}/plugin/html-sanitizer.js"/>
      <input file="${src.caja}/plugin/html-emitter.js"/>
      <input file="${src.caja}/plugin/csslexer.js"/>
      <input file="${src.caja}/plugin/sanitizecss.js"/>
      <input file="${src.caja}/plugin/cssparser.js"/>
      <input file="${src.caja}/plugin/bridal.js"/>
      <input file="${src.caja}/plugin/domado.js"/>
      <input file="${src.caja}/plugin/taming-schema.js"/>
      <input file="${src.caja}/plugin/taming-membrane.js"/>

      <input file="${src.caja}/plugin/uri.js"/>
      <input file="${src.caja}/ses-promise.js"/>
      <input file="${src.caja}/plugin/cajoling-service-client.js"/>
      <input file="${src.caja}/plugin/guest-manager.js"/>
      <input file="${src.caja}/plugin/ses-frame-group.js"/>
      <input file="${src.caja}/plugin/caja-iframe-done.js"/>
    </transform>
    <transform>
      <!-- ses-guest-frame: Used by caja.js when the browser is SES-capable.
      -->
      <output file="${lib}/ses-guest-frame.jslint.stamp"
       language="jslint"/>
      <!-- TODO(felix8a): closure cleanup
      <output file="${lib.caja}/plugin/ses-guest-frame.clo.js"
       language="closure"/>
      -->
      <output file="${lib.caja}/plugin/ses-guest-frame.opt.js"
       language="javascript" renderer="minify"/>
      <output file="${lib.caja}/plugin/ses-guest-frame.js"
       language="javascript" renderer="concat"/>
      <input file="${src.caja}/plugin/caja-iframe-build-version.js"/>
      <input file="${src.caja}/plugin/ses-iframe-init.js"/>
      <input file="${lib.caja}/ses/initSESPlus.js" jslint="false"/>
      <input file="${src.caja}/plugin/caja-iframe-done.js"/>
    </transform>
    <replace dir="${lib.caja}/plugin" propertyFile="${lib.caja}/reporting/buildInfo.properties" >
      <replacefilter token="%VERSION%" property="svnVersion" />
      <include name="es53-taming-frame.opt.js" />
      <include name="es53-taming-frame.js" />
      <include name="es53-guest-frame.opt.js" />
      <include name="es53-guest-frame.js" />
      <include name="ses-guest-frame.opt.js" />
      <include name="ses-guest-frame.js" />
      <include name="ses-taming-frame.opt.js" />
      <include name="ses-taming-frame.js" />
    </replace>
  </target>

  <target name="AllTests" depends="CajoledTests,CajolingServlet,PlaygroundBE,PlaygroundSupportingFiles,precajole-light">
    <javac destdir="${testlib}" debug="true" target="1.5" source="1.5">
      <src path="${tests}"/>
      <!-- TODO(felix8a): delete sourcepath when orphans cleaned up -->
      <sourcepath path="${src}:${tests}"/>
      <classpath refid="classpath.tests"/>
      <include name="**/caja/AllTests.java"/>
      <include name="**/caja/util/*.java"/>
      <include name="**/caja/**/*TestCase.java"/>
      <include name="**/caja/**/*Test.java"/>
      <include name="**/caja/plugin/BrowserTestCaseStub.java"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>

    <copy todir="${testlib}">
      <fileset dir="${tests}">
        <include name="**/caja/**/*.css"/>
        <include name="**/caja/**/*.golden"/>
        <include name="**/caja/**/*.gxp"/>
        <include name="**/caja/**/*.html"/>
        <include name="**/caja/**/*.input"/>
        <include name="**/caja/**/*.js"/>
        <include name="**/caja/**/*.txt"/>
        <include name="**/caja/**/*.xml"/>
      </fileset>
      <fileset dir="${third_party}">
        <include name="js/jqueryjs/runtest/env.js"/>
        <include name="js/jsunit/2.2/jsUnitCore.js"/>
        <include name="js/json_sans_eval/json_sans_eval.js"/>
      </fileset>
    </copy>
    <copy todir="${testlib}/com/google/caja/plugin"
          file="${third_party}/js/jsunit/2.2/jsUnitCore.js"/>
    <copy todir="${testlib}/com/google/caja/plugin/proxies">
      <fileset dir="${third_party}/js/proxies" />
    </copy>
    <copy todir="${testlib}">
      <fileset dir="${third_party}">
        <include name="js/es5conform/**/*.js"/>
      </fileset>
    </copy>
  </target>

  <target name="Version.set">
    <loadfile
       property="Version.old"
       srcFile="${lib.caja}/reporting/Version"
       failonerror="false">
      <filterchain><striplinebreaks/></filterchain>
    </loadfile>
    <exec outputproperty="build.svnVersion"
     executable="tools/svnversion-nocolon"
     failonerror="false"
     failifexecutionfails="false"
     dir="."/>
    <condition property="Version.changed">
      <not><equals arg1="${build.svnVersion}" arg2="${Version.old}"/></not>
    </condition>
  </target>

  <target name="Version.update" depends="Version.set" if="Version.changed">
    <!-- When svnversion changes, we need to recajole js and
         re-replace %VERSION%, so here we just nuke all target js -->
    <delete failonerror="false">
      <fileset dir="${lib}" includes="**/*.js"/>
      <fileset dir="${lib}" includes="**/*.html"/>
      <fileset dir="${precajolelib}" includes="**/data/*"/>
    </delete>
    <mkdir dir="${lib.caja}/reporting"/>
    <echo append="false" file="${lib.caja}/reporting/Version"
          message="${build.svnVersion}"/>
  </target>

  <target name="build.info" depends="dirs, Version.update">
    <tstamp>
      <format property="build.timestamp" pattern="yyyy-MM-dd HH:mm:ss"/>
    </tstamp>
    <echo append="false" file="${lib.caja}/reporting/buildInfo.properties"
     message="# Caja Build Information${line.separator}"/>
    <echo append="true" file="${lib.caja}/reporting/buildInfo.properties"
     message="svnVersion: ${build.svnVersion}${line.separator}"/>
    <echo append="true" file="${lib.caja}/reporting/buildInfo.properties"
     message="timestamp: ${build.timestamp}${line.separator}"/>
  </target>

  <target name="RuleDoclet" depends="HtmlParser">
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <include name="**/caja/quasiliteral/*Doclet.java"/>
      <include name="**/caja/tools/DocletAntTask.java"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>
    <taskdef name="ruledoclet" classname="com.google.caja.tools.DocletAntTask"
     classpathref="classpath.main" onerror="ignore"/>
  </target>

  <target name="PluginCompiler" depends="build.info, HtmlParser">
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <classpath refid="classpath.gwt"/>
      <include name="**/caja/plugin/*.java"/>
      <include name="**/caja/plugin/stages/*.java"/>
      <include name="**/caja/plugin/templates/*.java"/>
      <exclude name="**/caja/plugin/*Main.java"/>
      <exclude name="**/caja/plugin/BuildServiceImplementation.java"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>
    <copy todir="${lib}">
      <fileset dir="${src}">
        <include name="**/caja/cajita-promise.js"/>
        <include name="**/caja/es53.js"/>
        <include name="**/caja/console.js"/>
        <include name="**/caja/flash/caja-flash.js"/>
        <include name="**/caja/log-to-console.js"/>
        <include name="**/caja/plugin/bridal.js"/>
        <include name="**/caja/plugin/caja-gadget.css"/>
        <include name="**/caja/plugin/csslexer.js"/>
        <include name="**/caja/plugin/sanitizecss.js"/>
        <include name="**/caja/plugin/cssparser.js"/>
        <include name="**/caja/plugin/domado.js"/>
        <include name="**/caja/plugin/caja.js"/>
        <include name="**/caja/plugin/cajoling-service-client.js"/>
        <include name="**/caja/plugin/host-tools.js"/>
        <include name="**/caja/plugin/html-emitter.js"/>
        <include name="**/caja/plugin/html-sanitizer.js"/>
        <include name="**/caja/plugin/html-sanitizer-legacy.js"/>
        <include name="**/caja/plugin/json-rest-transport.js"/>
        <include name="**/caja/plugin/load-module.js"/>
        <include name="**/caja/plugin/plugin-base.js"/>
        <include name="**/caja/plugin/templates/*.json"/>
        <include name="**/caja/plugin/unicode.js"/>
        <include name="**/caja/plugin/uri.js"/>
      </fileset>
    </copy>

    <replace file="${lib.caja}/plugin/caja.js"
        propertyFile="${lib.caja}/reporting/buildInfo.properties" >
      <replacefilter token="%VERSION%" property="svnVersion" />
    </replace>
  </target>

  <!-- Builds the cajoling service. -->
  <target name="CajolingServlet" depends="HtmlParser">
    <javac destdir="${lib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <include name="**/caja/service/*.java"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>
  </target>

  <!-- Checks if playground needs rebuilding -->
  <target name="PlaygroundTimestamp">
    <uptodate property="uptodate.playground"
        targetfile="${war}/playground/playground.nocache.js">
      <srcfiles dir="${src.caja}/demos/playground/client" includes="**/*.java"/>
      <srcfiles dir="${src.caja}/demos/playground" includes="**/*.xml"/>
    </uptodate>
  </target>

  <target name="PlaygroundFE"
      depends="PlaygroundTimestamp, PlaygroundSupportingFiles"
      unless="uptodate.playground">
    <condition
        property="gwt.target.module"
        value="com.google.caja.demos.playground.Playground_dev"
        else="com.google.caja.demos.playground.Playground">
      <istrue value="${gwt.devground}"/>
    </condition>
    <javac destdir="${gwtlib}" debug="true" target="1.5" source="1.5">
      <src path="${src}"/>
      <classpath>
        <pathelement location="${lib}"/>
      </classpath>
      <classpath refid="classpath.main"/>
      <classpath refid="classpath.gwt"/>
    </javac>
    <java failonerror="true" fork="true"
     classname="com.google.gwt.dev.Compiler">
      <classpath>
        <pathelement location="src"/>
        <path refid="classpath.gwt"/>
      </classpath>
      <jvmarg value="-Xmx256M"/>
      <jvmarg value="-XX:CompileCommand=exclude,org/eclipse/core/internal/dtree/DataTreeNode,forwardDeltaWith" />
      <jvmarg value="-XX:CompileCommand=exclude,org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding,&lt;init&gt;" />
      <jvmarg value="-XX:CompileCommand=exclude,org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding,&lt;init&gt;" />
      <arg value="-style"/>
      <arg value="${gwt.style}"/>
      <arg value="-war"/>
      <arg value="${war}" />
      <arg value="${gwt.target.module}"/>
    </java>
  </target>

  <!-- Copies playground front end supporting files -->
  <target name="PSF" depends="PlaygroundSupportingFiles" />
  <target name="PlaygroundSupportingFiles" depends="CajoledTests,MinifiedJs">
    <copy todir="${war}">
      <!-- Needed by Playground.html -->
      <fileset dir="${third_party}/js/json_sans_eval">
        <include name="json_sans_eval.js" />
      </fileset>
      <fileset dir="${src.caja}">
        <include name="es53.js" />
      </fileset>
      <fileset dir="${src.caja}/plugin">
        <include name="bridal.js" />
        <include name="capture-cajoled-module.js" />
        <include name="capture-domado.js" />
        <include name="capture-taming-schema.js" />
        <include name="taming-schema.js" />
        <include name="capture-taming-membrane.js" />
        <include name="taming-membrane.js" />
        <!-- TODO(ihab.awad): ??? -->
        <include name="csslexer.js"/>
        <include name="sanitizecss.js"/>
        <include name="cssparser.js"/>
        <include name="domado.js" />
        <include name="html-emitter.js" />
        <include name="html-sanitizer.js" />
        <include name="unicode.js" />
        <include name="caja-gadget.css" />
      </fileset>
      <fileset dir="${lib.caja}/plugin">
        <include name="css-defs.js" />
        <include name="html4-defs.js" />
        <include name="domado.out.js" />
        <include name="html-sanitizer-bundle.js" />
        <include name="html-sanitizer-minified.js" />
        <include name="html-css-sanitizer-bundle.js" />
        <include name="html-css-sanitizer-closured.js" />
        <include name="html-css-sanitizer-minified.js" />
        <include name="taming-membrane.out.js" />
      </fileset>
      <fileset dir="${third_party}/js/excanvas">
        <include name="excanvas.js" />
      </fileset>
      <fileset dir="${third_party}/js/prettify">
        <include name="lang-css.js" />
        <include name="prettify.js" />
        <include name="prettify.css" />
      </fileset>
      <fileset dir="${src.caja}/demos/playground">
        <include name="ajax-loader.gif" />
        <include name="Playground.html" />
        <include name="Playground.css" />
        <include name="es53.html" />
        <include name="testbed.js" />
        <include name="policy.js" />
        <include name="favicon.ico" />
      </fileset>
      <fileset dir="${third_party}/js/codemirror">
        <include name="js/*.js" />
        <include name="css/*.css" />
      </fileset>
      <fileset dir="${src.caja}/demos/flash">
        <include name="Boxed.swf" />
      </fileset>
      <fileset dir="${src.caja}/flash">
        <include name="caja-flash.js" />
        <include name="flashbridge.swf" />
      </fileset>
      <fileset dir="${src.caja}/flash/tests">
        <include name="BridgeAware.swf" />
        <include name="BridgeOblivious.swf" />
      </fileset>
      <fileset dir="${src.caja}/demos/playground">
        <include name="examples/*.gif" />
        <include name="examples/*.html" />
        <include name="examples/*.js" />
        <include name="examples/unboxed/*.html" />
        <include name="examples/unboxed/*.png" />
      </fileset>

      <!-- Needed by jqueryTest which references the playground
        -  server so as to be standalone. -->
      <fileset dir="${third_party}/js/jqueryjs/test/">
        <include name="core.html"/>
      </fileset>

      <!-- Needed by container-dynamic.html which references the playground
        -  server so as to be standalone. -->
      <fileset dir="${src.caja}">
        <include name="log-to-console.js"/>
        <include name="cajita-promise.js"/>
      </fileset>
      <fileset dir="${lib.caja}/plugin">
        <include name="caja.js"/>
        <include name="caja-minified.js"/>
      </fileset>
    </copy>

    <mkdir dir="${war}/${build.svnVersion}" />
    <copy todir="${war}/${build.svnVersion}">
      <!-- For iframe-based Caja loading - TODO(kpreid): this should become
           part of a "Caja server" package separate from the playground. -->
      <fileset dir="${lib.caja}/plugin">
        <include name="es53-guest-frame.js"/>
        <include name="es53-guest-frame.opt.js"/>
        <include name="es53-taming-frame.js"/>
        <include name="es53-taming-frame.opt.js"/>
        <include name="ses-taming-frame.js"/>
        <include name="ses-taming-frame.opt.js"/>
        <include name="ses-guest-frame.js"/>
        <include name="ses-guest-frame.opt.js"/>
      </fileset>
    </copy>

    <copy file="${third_party}/js/swfobject/src/swfobject.js"
          tofile="${war}/swfobject.js"/>
    <transform>
      <input file="${third_party}/js/swfobject/src/swfobject.js"/>
      <output file="${war}/swfobject.opt.js"
              language="javascript" renderer="minify"/>
    </transform>

    <copy todir="${war}/sunspider">
      <fileset dir="${third_party}/js/sunspider-benchmark">
        <include name="sunspider-record-result.js" />
        <include name="*.html" />
      </fileset>
    </copy>
  </target>

  <!-- Copy third-party JARs to the WAR directory -->
  <target name="PlaygroundJars" depends="dirs">
    <mkdir dir="${war}/WEB-INF" />
    <copy todir="${war}/WEB-INF/lib" flatten="true">
      <fileset dir="${third_party}/java/jsonml">
        <include name="jsonml.jar"/>
      </fileset>
      <fileset dir="${third_party}/java/appengine/lib/user">
        <include name="**/*.jar" />
      </fileset>
      <fileset dir="${third_party}/java/gwt">
        <include name="gwt-servlet.jar" />
      </fileset>
      <fileset dir="${third_party}/java/xerces/">
        <include name="xercesImpl.jar" />
      </fileset>
      <fileset dir="${third_party}/java/guava">
        <include name="guava-r09.jar" />
      </fileset>
      <fileset dir="${third_party}/java/json_simple/">
        <include name="json_simple.jar" />
      </fileset>
      <fileset dir="${third_party}/java/jakarta_commons/">
        <include name="commons-io-1.4.jar" />
        <include name="commons-codec-1.4.jar" />
      </fileset>
      <fileset dir="${third_party}/java/jakarta_commons/">
        <include name="commons-fileupload-1.2.1.jar" />
      </fileset>
    </copy>
    <copy todir="${war}/WEB-INF"
     file="${third_party}/java/appengine/config/user/logging.properties" />
  </target>

  <!-- Compile the GWT backend and copies to the WAR -->
  <target name="PlaygroundBE" depends="pluginc,PlaygroundJars,precajole">
    <copy todir="${war}/WEB-INF" file="web.xml" />
    <copy todir="${war}/WEB-INF/lib">
      <fileset dir="${jars}">
        <include name="htmlparser.jar"/>
        <include name="precajole.jar"/>
      </fileset>
    </copy>
    <mkdir dir="${war}/WEB-INF/classes" />
    <copy todir="${war}/WEB-INF/classes">
      <fileset dir="${lib}">
        <include name="com/**" />
      </fileset>
    </copy>
    <javac destdir="${war}/WEB-INF/classes" debug="true">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <classpath refid="classpath.gwt"/>
      <include name="**/caja/demos/playground/server/*.java"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>
    <javac destdir="${lib}" debug="true">
      <src path="${src}"/>
      <classpath refid="classpath.main"/>
      <classpath refid="classpath.gwt"/>
      <include name="**/caja/demos/playground/server/**/*.java"/>
      <compilerarg line="-Xlint:unchecked"/>
    </javac>
  </target>

  <target name="appengine-web" depends="build.info">
    <copy file="appengine-web.xml"
          tofile="${war}/WEB-INF/appengine-web.xml"
          overwrite="true">
      <filterset filtersfile="${lib.caja}/reporting/buildInfo.properties" />
    </copy>
  </target>

  <target name="alt-appengine-web" depends="build.info">
    <copy file="../alt-appengine-web.xml"
          tofile="${war}/WEB-INF/appengine-web.xml"
          overwrite="true">
      <filterset filtersfile="${lib.caja}/reporting/buildInfo.properties" />
    </copy>
  </target>

  <target name="playground"
   depends="CajolingServlet, PlaygroundBE, PlaygroundFE, appengine-web"
   description="Builds the playground">
    <!-- In some situations, browsers disagree on what location
      to assign to a constructed iframe, which makes it awkward
      to use relative pathnames that will work in all browsers.
      A straightforward workaround is to make the necessary files
      available in both locations.
      http://groups.google.com/group/google-caja-discuss/msg/b908b16edbc6a112
      -->
    <copy todir="${war}/playground/">
      <fileset dir="${third_party}/js/codemirror">
        <include name="js/*.js" />
        <include name="css/*.css" />
      </fileset>
    </copy>
  </target>

  <target name="alt-playground">
    <antcall target="playground">
      <param name="gwt.style" value="PRETTY"/>
    </antcall>
    <antcall target="alt-appengine-web"/>
  </target>

  <target name="deploy" depends="playground">
    <appcfg action="update" war="${war}" />
  </target>

  <target name="alt-deploy" depends="alt-playground">
    <appcfg action="update" war="${war}" />
  </target>

  <target name="runserver" depends="playground,photon,jquery,trycaja"
    description="Starts the development server.">
    <dev_appserver war="${war}">
      <options>
        <arg value="--jvm_flag=-Xmx2048m"/>
        <arg value="--jvm_flag=-Dappengine.user.timezone=UTC"/>
      </options>
    </dev_appserver>
  </target>

  <target name="runserver-debug" depends="playground,photon"
    description="Starts the development server with debug port.">
    <dev_appserver war="${war}">
      <options>
        <arg value="--jvm_flag=-Xmx2048m"/>
        <arg value="--jvm_flag=-Xrunjdwp:transport=dt_socket,address=9999,server=y,suspend=n"/>
        <arg value="--jvm_flag=-Dappengine.user.timezone=UTC"/>
      </options>
    </dev_appserver>
  </target>

  <target name="HtmlParser" depends="dirs">
    <javac destdir="${third_party}/java/htmlparser/lib" debug="true"
     target="1.5" source="1.5">
      <src path="${third_party}/java/htmlparser/src"/>
      <classpath refid="classpath.main"/>
      <include name="**/*.java"/>
      <exclude name="nu/validator/htmlparser/dom/**/*.java"/>
      <exclude name="nu/validator/htmlparser/extra/**/*.java"/>
      <exclude name="nu/validator/htmlparser/io/**/*.java"/>
      <exclude name="nu/validator/htmlparser/sax/**/*.java"/>
      <exclude name="nu/validator/htmlparser/xom/**/*.java"/>
      <compilerarg line="-Xlint:none"/>
    </javac>
    <jar basedir="${third_party}/java/htmlparser/src/"
     destfile="${jars}/htmlparser-src.jar">
      <include name="**/*.java"/>
      <exclude name="nu/validator/htmlparser/dom/**/*.java"/>
      <exclude name="nu/validator/htmlparser/extra/**/*.java"/>
      <exclude name="nu/validator/htmlparser/io/**/*.java"/>
      <exclude name="nu/validator/htmlparser/sax/**/*.java"/>
      <exclude name="nu/validator/htmlparser/xom/**/*.java"/>
    </jar>
    <jar destfile="${jars}/htmlparser.jar"
     basedir="${third_party}/java/htmlparser/lib" />
  </target>

  <target name="photon" depends="jars"
   description="Photon demo">
    <mkdir dir="${war}/photon"/>
    <copy todir="${war}/photon">
      <fileset dir="${src.caja}/demos/photon">
        <include name="container/**"/>
        <include name="gadgets/**"/>
      </fileset>
    </copy>
  </target>

  <target name="trycaja" depends="jars"
   description="TryCaja tutorial">
    <mkdir dir="${war}/trycaja"/>
    <copy todir="${war}/trycaja">
      <fileset dir="${src.caja}/demos/trycaja">
        <include name="**"/>
      </fileset>
    </copy>
  </target>
  
  <target name="demos" depends="jars"
   description="Examples of hosting gadgets/modules.">
    <mkdir dir="${www}/container"/>

    <transform>
      <output
       file="${lib.caja}/demos/container/gadget-library.out.js"
       language="caja" onlyJsEmitted="true" debug="false"/>
      <input file="${demos}/container/gadget-library.js"/>
    </transform>
    <transform>
      <output
       file="${lib.caja}/demos/container/gadget-trivial.out.js"
       language="caja" onlyJsEmitted="true" debug="false"/>
      <input file="${demos}/container/gadget-trivial.html"/>
    </transform>

    <copy todir="${www}/container">
      <fileset dir="${src.caja}">
        <include name="log-to-console.js"/>
      </fileset>
      <fileset dir="${src.caja}/flash">
        <include name="caja-flash.js"/>
      </fileset>
      <fileset dir="${src.caja}/plugin">
        <include name="caja-gadget.css"/>
        <include name="caja.js"/>
      </fileset>
      <fileset dir="${lib.caja}/demos/container">
        <include name="*.out.js"/>
      </fileset>
      <fileset dir="${demos}/container">
        <include name="container-*.html"/>
        <include name="gadget-*.html"/>
        <include name="gadget-*.js"/>
      </fileset>
    </copy>
  </target>

  <target name="init.maven.tasks">
    <path id="maven.ant.tasks.classpath" path="${maven.ant.tasks.jar}" />
    <typedef resource="org/apache/maven/artifact/ant/antlib.xml" 
             uri="urn:maven-artifact-ant" 
             classpathref="maven.ant.tasks.classpath" /> 
  </target>

  <!-- Generate pom.xml with the proper svn build number -->
  <target name="pom" depends="init.maven.tasks,build.info">
    <copy file="caja-template.pom" tofile="${maven}/pom.xml">
      <filterset>
        <filter token="build.svnVersion" value="${build.svnVersion}"/>
      </filterset>
    </copy>

    <property name="maven-jarfile-nodeps" value="${jars}/pluginc.jar" />
    <property name="maven-jarfile-javadoc" value="${jars}/pluginc-javadocs.jar"/>
    <property name="maven-jarfile-sources" value="${jars}/pluginc-src.jar" />

    <artifact:pom id="project" file="${maven}/pom.xml" />
  </target>


  <target name="mvn-install" depends="jars,javadocs,pom">
    <artifact:install file="${maven-jarfile-nodeps}">
      <pom refid="project"/>
      <attach file="${maven-jarfile-javadoc}" classifier="javadoc"/>
      <attach file="${maven-jarfile-sources}" classifier="sources"/>
    </artifact:install>
  </target>

  <!-- The mvn-deploy target takes the generated maven artifacts and pushes
       them to the Sonatype repository.  You will need to have a
       gpg key defined and account set up. More docs on how to do this here:

       https://docs.sonatype.org/display/Repository/Sonatype+OSS+Maven+Repository+Usage+Guide
  -->

  <target name="mvn-deploy"
    depends="mvn-install"
    description="Signs and Deploys caja artifacts to the central maven repo">

    <!-- sign and deploy the main artifact -->
    <artifact:mvn>
      <arg value="org.apache.maven.plugins:maven-gpg-plugin:1.1:sign-and-deploy-file" />
      <arg value="-Durl=${maven-repository-url}" />
      <arg value="-DrepositoryId=${maven-repository-id}" />
      <arg value="-DpomFile=${maven}/pom.xml" />
      <arg value="-Dfile=${maven-jarfile-nodeps}" />
      <arg value="-Pgpg" />
    </artifact:mvn>

    <!-- sign and deploy the sources artifact -->
    <artifact:mvn>
      <arg value="org.apache.maven.plugins:maven-gpg-plugin:1.1:sign-and-deploy-file" />
      <arg value="-Durl=${maven-repository-url}" />
      <arg value="-DrepositoryId=${maven-repository-id}" />
      <arg value="-DpomFile=${maven}/pom.xml" />
      <arg value="-Dfile=${maven-jarfile-sources}" />
      <arg value="-Dclassifier=sources" />
      <arg value="-Pgpg" />
    </artifact:mvn>

    <!-- sign and deploy the javadoc artifact -->
    <artifact:mvn>
      <arg value="org.apache.maven.plugins:maven-gpg-plugin:1.1:sign-and-deploy-file" />
      <arg value="-Durl=${maven-repository-url}" />
      <arg value="-DrepositoryId=${maven-repository-id}" />
      <arg value="-DpomFile=${maven}/pom.xml" />
      <arg value="-Dfile=${maven-jarfile-javadoc}" />
      <arg value="-Dclassifier=javadoc" />
      <arg value="-Pgpg" />
    </artifact:mvn>
  </target>


  <!--
    - Enable Emma
    -
    - See
    - * http://wiki.metawerx.net/Wiki.jsp
    -   ?page=UsingEMMAWithANTForJUnitTestCoverageReporting
    - * http://emma.sourceforge.net/reference_single/reference.html#tool-ref.run
   -->
  <target name="emma" depends="dirs"
   description="Turns on EMMA instrumentation and reporting.">
    <property name="emma.enabled" value="true" />
    <!--
      - See http://emma.sourceforge.net/reference/ch02s06s02.html
      - This property can be overriden via -Demma.filter=<list of filter specs>
      - on ANT's command line, will set the coverage filter; by default, all
      - com.google classes found in ${lib} will be instrumented.
      - org.commons.cli.apache and other third_party classes will not be.
     -->
    <property name="emma.filter" value="com.google.*"/>
  </target>

  <target name="reportAllFailure"
      description="Do not skip known failures when running tests.">
    <property name="test.failureNotAnOption" value="true" />
  </target>

  <target name="devground"
      description="Builds playground with only one GWT permutation">
    <property name="gwt.devground" value="true"/>
    <antcall target="playground"/>
  </target>

  <macrodef name="buildSwf">
    <attribute name="in"/>
    <attribute name="out"/>
    <sequential>
      <exec executable="mxmlc" failonerror="true">
        <arg value="--source-path=${src}"/>
        <arg value="--debug=true"/>
        <arg value="--static-link-runtime-shared-libraries"/>
        <arg value="--show-actionscript-warnings=true"/>
        <arg value="-o"/>
        <arg value="@{out}"/>
        <arg value="@{in}"/>
      </exec>
    </sequential>
  </macrodef>

  <property name="src.flash" value="${src.caja}/flash"/>

  <!-- This is not automatic, because it requires Flex, and the
       Flex license doesn't allow adding it to third_party -->
  <target name="flash"
          description="Rebuild Flash swf files">
    <buildSwf in="${src.flash}/FlashBridge.as"
              out="${src.flash}/flashbridge.swf"/>
    <buildSwf in="${src.flash}/tests/BridgeAware.mxml"
              out="${src.flash}/tests/BridgeAware.swf"/>
    <buildSwf in="${src.flash}/tests/BridgeOblivious.mxml"
              out="${src.flash}/tests/BridgeOblivious.swf"/>
  </target>

  <target name="precajole-light" depends="tools">
    <precajole spec="${precajolesrc}/light.xml" dest="${precajolelib}/light" />
  </target>

  <target name="precajole" depends="tools">
    <precajole spec="${precajolesrc}/heavy.xml" dest="${precajolelib}/heavy" />
    <jar destfile="${jars}/precajole.jar" basedir="${precajolelib}/heavy" />
  </target>

  <target name="printlibs">
    <pathconvert
       refid="classpath.tests"
       pathsep="${line.separator}">
     <map from="${basedir}/" to=""/>
    </pathconvert>
  </target>

</project>