poi/build.xml

<?xml version="1.0"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you 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.
-->

<!--
    POI Build System.  Written by:

        Glen Stampoultzis   glens at apache.org

    Modified by:

        Rainer Klute        klute@rainer-klute.de
        Bruno Girin         brunogirin@gmail.com
        Yegor Kozlov        yegor at apache.org
        Dominik Stadler     centic at apache.org

    This build was tested with ant 1.9.4 although it will probably work with
    other versions, however at least 1.8.0 is required.

    To build the documentation you will need to install forrest and set
    the FORREST_HOME environment variable.  Forrest 0.5.1 required.

    Since POI 3.11 you will need JDK 1.6 or newer to build POI.

    Some people may find the tests hang when run through Ant. If this
    happens to you, try giving Ant some more memory when you run it, eg:
          ANT_OPTS="-Xmx1024m -XX:MaxPermSize=256m" ant test

 -->
<project name="POI Build" default="help" basedir="." xmlns:mvn="antlib:org.apache.maven.artifact.ant">

    <description>The Apache POI project Ant build.</description>

    <property name="version.id" value="3.14-beta1"/>
    <property name="version.rel" value="REL_3_14_BETA1"/>

    <property environment="env"/>
    <!-- the repository to download jars from -->
    <property name="repository.m2" value="http://repo1.maven.org"/>

    <property name="main.lib" location="lib"/>
    <property name="ooxml.lib" location="ooxml-lib"/>
    <property name="compile.lib" location="compile-lib"/>
    <property name="forrest.home" value="${env.FORREST_HOME}"/>

    <!-- compiler options options -->
    <property name="jdk.version.source" value="1.6" description="JDK version of source code"/>
    <property name="jdk.version.class" value="1.6" description="JDK version of generated class files"/>
    <property name="compile.debug" value="true"/>

    <!--
        Logging is suppressed by default.
        To redirect log output to console, run ant with -Dorg.apache.poi.util.POILogger=org.apache.poi.util.SystemOutLogger
    -->
    <property name="org.apache.poi.util.POILogger" value="org.apache.poi.util.NullLogger"/>

    <!-- issue warnings if source code contains unmappable characters for encoding ASCII  -->
    <property name="java.source.encoding" value="ASCII"/>

    <scriptdef name="propertyreset" language="javascript"
        description="Allows to assign @{property} new value">
        <attribute name="name"/>
        <attribute name="value"/>
            project.setProperty(attributes.get("name"), attributes.get("value"));
    </scriptdef>

    <!--
      JVM system properties for running tests,
      user.language and user.country are required as we have locale-sensitive formatters
    -->
    <property name="testpattern" value="Test*"/>
    <property name="POI.testdata.path" value="test-data"/>
    <property name="java.awt.headless" value="true"/>
    <property name="additionaljar" value=""/>
    <propertyreset name="user.language" value="en"/>
    <propertyreset name="user.country" value="US"/>
    <condition property="http_proxy" value="${env.http_proxy}" else="">
        <isset property="env.http_proxy"/>
    </condition>
    <!-- Fix for strange woodstox references in gump build -->
    <property name="javax.xml.stream.XMLInputFactory" value="com.sun.xml.internal.stream.XMLInputFactoryImpl"/>

    <!-- Main: -->
    <property name="main.resource1.dir" value="src/resources/main"/>
    <property name="main.src" location="src/java"/>
    <property name="main.src.test" location="src/testcases"/>
    <property name="main.documentation" value="src/documentation"/>
    <property name="main.output.dir" location="build/classes"/>
    <property name="main.output.test.dir" location="build/test-classes"/>
    <property name="main.reports.test" location="build/test-results"/>
    <property name="main.testokfile" location="build/main-testokfile.txt"/>

    <!-- Scratchpad: -->
    <property name="scratchpad.resource1.dir" value="src/resources/scratchpad"/>
    <property name="scratchpad.src" location="src/scratchpad/src"/>
    <property name="scratchpad.src.test" location="src/scratchpad/testcases"/>
    <property name="scratchpad.reports.test" location="build/scratchpad-test-results"/>
    <property name="scratchpad.output.dir" location="build/scratchpad-classes"/>
    <property name="scratchpad.output.test.dir" location="build/scratchpad-test-classes"/>
    <property name="scratchpad.testokfile" location="build/scratchpad-testokfile.txt"/>

    <!-- Scratchpad/Geometry -->
    <property name="geometry.pkg" value="org.apache.poi.sl.draw.binding"/>
    <property name="geometry.output.tmpdir" value="build/geometry-java"/>

    <!-- Examples: -->
    <property name="examples.src" location="src/examples/src"/>
    <property name="examples.output.dir" location="build/examples-classes"/>

    <!-- OOXML support: -->
    <property name="ooxml.src" location="src/ooxml/java"/>
    <property name="ooxml.resource1.dir" value="src/resources/ooxml"/>
    <property name="ooxml.src.test" location="src/ooxml/testcases"/>
    <property name="ooxml.reports.test" location="build/ooxml-test-results"/>
    <property name="ooxml.output.dir" location="build/ooxml-classes"/>
    <property name="ooxml.output.test.dir" location="build/ooxml-test-classes"/>
    <property name="ooxml.testokfile" location="build/ooxml-testokfile.txt"/>
    <property name="ooxml.lite.output.dir" location="build/ooxml-lite-classes"/>

    <!-- Integration testing -->
    <property name="integration.src.test" location="src/integrationtest"/>
    <property name="integration.reports.test" location="build/integration-test-results"/>
    <property name="integration.output.test.dir" location="build/integration-test-classes"/>
    <property name="integration.testokfile" location="build/integration-testokfile.txt"/>

    <!-- Excelant: -->
    <property name="excelant.resource.dir" value="src/excelant/resources"/>
    <property name="excelant.src" location="src/excelant/java"/>
    <property name="excelant.src.test" location="src/excelant/testcases"/>
    <property name="excelant.reports.test" location="build/excelant-test-results"/>
    <property name="excelant.output.dir" location="build/excelant-classes"/>
    <property name="excelant.output.test.dir" location="build/excelant-test-classes"/>
    <property name="excelant.testokfile" location="build/excelant-testokfile.txt"/>

    <!-- jars in the /lib directory, see the fetch-jars target-->
    <property name="main.commons-logging.jar" location="${main.lib}/commons-logging-1.2.jar"/>
    <property name="main.commons-logging.url"
              value="${repository.m2}/maven2/commons-logging/commons-logging/1.2/commons-logging-1.2.jar"/>
    <property name="main.commons-codec.jar" location="${main.lib}/commons-codec-1.10.jar"/>
    <property name="main.commons-codec.url"
              value="${repository.m2}/maven2/commons-codec/commons-codec/1.10/commons-codec-1.10.jar"/>
    <property name="main.log4j.jar" location="${main.lib}/log4j-1.2.17.jar"/>
    <property name="main.log4j.url" value="${repository.m2}/maven2/log4j/log4j/1.2.17/log4j-1.2.17.jar"/>
    <property name="main.junit.jar" location="${main.lib}/junit-4.12.jar"/>
    <property name="main.junit.url" value="${repository.m2}/maven2/junit/junit/4.12/junit-4.12.jar"/>
    <property name="main.hamcrest.jar" location="${main.lib}/hamcrest-core-1.3.jar"/>
    <property name="main.hamcrest.url" value="${repository.m2}/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"/>
    <property name="main.ant.jar" location="${main.lib}/ant-1.9.4.jar"/>
    <property name="main.ant.url" value="${repository.m2}/maven2/org/apache/ant/ant/1.9.4/ant-1.9.4.jar"/>
    <property name="main.antlauncher.jar" location="${main.lib}/ant-launcher-1.9.4.jar"/>
    <property name="main.antlauncher.url" value="${repository.m2}/maven2/org/apache/ant/ant-launcher/1.9.4/ant-launcher-1.9.4.jar"/>

    <!-- xml signature libs -->
    <property name="dsig.xmlsec.jar" location="${compile.lib}/xmlsec-2.0.5.jar"/>
    <property name="dsig.xmlsec.url" value="${repository.m2}/maven2/org/apache/santuario/xmlsec/2.0.5/xmlsec-2.0.5.jar"/>
    <property name="dsig.bouncycastle-prov.jar" location="${compile.lib}/bcprov-ext-jdk15on-1.53.jar"/>
    <property name="dsig.bouncycastle-prov.url" value="${repository.m2}/maven2/org/bouncycastle/bcprov-ext-jdk15on/1.53/bcprov-ext-jdk15on-1.53.jar"/>
    <property name="dsig.bouncycastle-pkix.jar" location="${compile.lib}/bcpkix-jdk15on-1.53.jar"/>
    <property name="dsig.bouncycastle-pkix.url" value="${repository.m2}/maven2/org/bouncycastle/bcpkix-jdk15on/1.53/bcpkix-jdk15on-1.53.jar"/>
    <property name="dsig.sl4j-api.jar" location="${compile.lib}/slf4j-api-1.7.12.jar"/>
    <property name="dsig.sl4j-api.url" value="${repository.m2}/maven2/org/slf4j/slf4j-api/1.7.12/slf4j-api-1.7.12.jar"/>

    <!-- jars in the lib-ooxml directory, see the fetch-ooxml-jars target-->
    <property name="ooxml.curvesapi.jar" location="${ooxml.lib}/curvesapi-1.03.jar"/>
    <property name="ooxml.curvesapi.url"
              value="${repository.m2}/maven2/com/github/virtuald/curvesapi/1.03/curvesapi-1.03.jar"/>
    <property name="ooxml.xmlbeans23.jar" location="${ooxml.lib}/xmlbeans-2.3.0.jar"/>
    <property name="ooxml.xmlbeans23.url"
              value="${repository.m2}/maven2/org/apache/xmlbeans/xmlbeans/2.3.0/xmlbeans-2.3.0.jar"/>
    <property name="ooxml.xmlbeans26.jar" location="${ooxml.lib}/xmlbeans-2.6.0.jar"/>
    <property name="ooxml.xmlbeans26.url"
              value="${repository.m2}/maven2/org/apache/xmlbeans/xmlbeans/2.6.0/xmlbeans-2.6.0.jar"/>

    <!-- coverage libs -->
    <property name="jacoco.zip" location="${main.lib}/jacoco-0.7.4.201502262128.zip"/>
    <property name="jacoco.url" value="${repository.m2}/maven2/org/jacoco/jacoco/0.7.4.201502262128/jacoco-0.7.4.201502262128.zip"/>
    <property name="asm.jar" location="${main.lib}/asm-all-5.0.3.jar"/>
    <property name="asm.url" value="${repository.m2}/maven2/org/ow2/asm/asm-all/5.0.3/asm-all-5.0.3.jar"/>

    <!-- license and api checks -->
    <property name="rat.jar" location="${main.lib}/apache-rat-0.11.jar"/>
    <property name="rat.url" value="${repository.m2}/maven2/org/apache/rat/apache-rat/0.11/apache-rat-0.11.jar"/>
    <property name="forbidden.jar" location="${main.lib}/forbiddenapis-2.0.jar"/>
    <property name="forbidden.url" value="${repository.m2}/maven2/de/thetaphi/forbiddenapis/2.0/forbiddenapis-2.0.jar"/>

    <!-- See http://www.ecma-international.org/publications/standards/Ecma-376.htm -->
    <!-- "Copy these file(s), free of charge" -->
    <property name="ooxml.xsds.ozip.1" value="OfficeOpenXML-Part4.zip"/>
    <property name="ooxml.xsds.izip.1" value="OfficeOpenXML-XMLSchema.zip"/>
    <property name="ooxml.xsds.url.1"
              value="http://www.ecma-international.org/publications/files/ECMA-ST/Office%20Open%20XML%201st%20edition%20Part%204%20(PDF).zip"/>
    <property name="ooxml.xsds.src.dir" location="build/ooxml-xsds-src"/>
    <property name="ooxml.xsds.src.jar" location="${ooxml.lib}/ooxml-schemas-1.2-sources.jar"/>
    <property name="ooxml.xsds.jar" location="${ooxml.lib}/ooxml-schemas-1.2.jar"/>

    <!-- additional schemas are packed into the poi schemas jar, -->
    <!-- so we don't have to care about a seperate versioning of the original ooxml schemas -->
    <property name="ooxml.xsds.dc.1" value="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dc.xsd"/>
    <property name="ooxml.xsds.dc.2" value="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dcterms.xsd"/>
    <property name="ooxml.xsds.dc.3" value="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dcmitype.xsd"/>
    <property name="ooxml.xsds.dsig.1" value="http://www.w3.org/TR/2002/REC-xmldsig-core-20020212/xmldsig-core-schema.xsd"/>
    <property name="ooxml.xsds.dsig.2" value="http://uri.etsi.org/01903/v1.3.2/XAdES.xsd"/>
    <property name="ooxml.xsds.dsig.3" value="http://uri.etsi.org/01903/v1.4.1/XAdESv141.xsd"/>
    <property name="ooxml.xsds.ozip.2" value="OfficeOpenXML-Part2.zip"/>
    <property name="ooxml.xsds.izip.2" value="OpenPackagingConventions-XMLSchema.zip"/>
    <property name="ooxml.xsds.url.2"
              value="http://www.ecma-international.org/publications/files/ECMA-ST/Office%20Open%20XML%201st%20edition%20Part%202%20(PDF).zip"/>
    <property name="ooxml.security.src.dir" location="build/ooxml-security-src"/>
    <property name="ooxml.security.src.jar" location="${ooxml.lib}/ooxml-security-1.0-sources.jar"/>
    <property name="ooxml.security.jar" location="${ooxml.lib}/ooxml-security-1.0.jar"/>
    <property name="ooxml.security.xsd.dir" location="src/ooxml/resources/org/apache/poi/poifs/crypt"/>
    <property name="ooxml.visio.xsd.dir" location="src/ooxml/resources/org/apache/poi/xdgf"/>

    <property name="maven.ooxml.xsds.version.id" value="1.0"/>
    <property name="maven.ooxml.xsds.jar" value="ooxml-schemas-${maven.ooxml.xsds.version.id}.jar"/>

    <!-- Coverage -->
    <property name="coverage.dir" value="build/coverage"/>
    <!-- Exclude some uninteresting classes from coverage-instrumentation as we do not want to measure coverage in those packages anyway -->
    <property name="coverage.excludes" value="org.openxmlformats.*:com.*:org.junit.*:junit.*:org.etsi.*:org.w3.*"/>

    <!-- Apache RAT license check properties -->
    <property name="rat.reportdir" value="build/rat"/>
    <property name="rat.report" value="${rat.reportdir}/report.txt"/>

    <!-- build and distro settings -->
    <property name="jar.name" value="poi"/>
    <property name="build.site" location="build/tmp/site/build/site"/>
    <property name="build.site.src" location="build/tmp/site"/>
    <property name="apidocs.report.dir" location="${build.site}/apidocs"/>
    <property name="dist.dir" location="build/dist"/>
    <property name="halt.on.test.failure" value="true"/>

    <propertyset id="junit.properties">
        <propertyref name="POI.testdata.path"/>
        <propertyref name="java.awt.headless"/>
        <propertyref name="org.apache.poi.util.POILogger"/>
        <propertyref name="http_proxy"/>
        <propertyref name="additionaljar"/>
        <propertyref name="user.language"/>
        <propertyref name="user.country"/>
        <propertyref name="javax.xml.stream.XMLInputFactory"/>
    </propertyset>

    <path id="main.classpath">
        <pathelement location="${main.commons-logging.jar}"/>
        <pathelement location="${main.commons-codec.jar}"/>
        <pathelement location="${main.log4j.jar}"/>
        <pathelement location="${main.junit.jar}"/>
        <pathelement location="${main.hamcrest.jar}"/>
    </path>

    <path id="scratchpad.classpath">
        <path refid="main.classpath"/>
        <pathelement location="${main.output.dir}"/>
    </path>

    <path id="ooxml.xmlsec.classpath">
        <pathelement location="${dsig.xmlsec.jar}"/>
        <pathelement location="${dsig.bouncycastle-prov.jar}"/>
        <pathelement location="${dsig.bouncycastle-pkix.jar}"/>
        <pathelement location="${dsig.sl4j-api.jar}"/>
    </path>

    <path id="ooxml.classpath">
        <pathelement location="${ooxml.curvesapi.jar}"/>
        <pathelement location="${ooxml.xmlbeans26.jar}"/>
        <pathelement location="${ooxml.xsds.jar}"/>
        <path refid="main.classpath"/>
        <pathelement location="${main.output.dir}"/>
        <pathelement location="${ooxml.security.jar}"/>
        <!-- classes are omitted on test cases outside the xml-dsign area to avoid classpath poisioning -->
        <!--path refid="ooxml.xmlsec.classpath"/-->
        <!-- Used only for ExtractorFactory, see #57963 -->
        <pathelement location="${scratchpad.output.dir}"/>
    </path>

    <path id="test.classpath">
        <path refid="main.classpath"/>
        <pathelement location="${main.output.dir}"/>
        <pathelement location="${main.output.test.dir}"/>
        <pathelement location="${additionaljar}"/>
    </path>

    <path id="test.scratchpad.classpath">
        <path refid="scratchpad.classpath"/>
        <pathelement location="${main.output.test.dir}"/>
        <pathelement location="${scratchpad.output.dir}"/>
        <pathelement location="${scratchpad.output.test.dir}"/>
        <pathelement location="${additionaljar}"/>
    </path>

    <path id="test.ooxml.classpath">
        <path refid="ooxml.classpath"/>
        <pathelement location="${ooxml.output.dir}"/>
        <pathelement location="${ooxml.output.test.dir}"/>
        <pathelement location="${main.output.test.dir}"/>
        <pathelement location="${additionaljar}"/>
    </path>

    <path id="test.integration.classpath">
        <path refid="scratchpad.classpath"/>
        <path refid="ooxml.classpath"/>
        <pathelement location="${main.output.test.dir}"/>
        <pathelement location="${ooxml.output.dir}"/>
        <pathelement location="${integration.output.test.dir}"/>
    </path>

    <path id="ooxml-lite.classpath">
        <pathelement location="${ooxml.curvesapi.jar}"/>
        <pathelement location="${ooxml.xmlbeans26.jar}"/>
        <pathelement location="${ooxml.lite.output.dir}"/> <!-- instead of ooxml-xsds.jar use the filtered classes-->
        <path refid="main.classpath"/>
        <pathelement location="${main.output.dir}"/>
        <pathelement location="${scratchpad.output.dir}"/>
        <!--path refid="ooxml.classpath"/-->
        <pathelement location="${ooxml.output.dir}"/>
        <pathelement location="${ooxml.output.test.dir}"/>
        <pathelement location="${main.output.test.dir}"/>
        <pathelement location="${ooxml.security.jar}"/>
    </path>


    <path id="examples.classpath">
        <path refid="main.classpath"/>
        <pathelement location="${main.output.dir}"/>
        <pathelement location="${scratchpad.output.dir}"/>
    </path>

    <path id="excelant.classpath">
        <path refid="ooxml.classpath"/>
        <pathelement location="${main.ant.jar}"/>
        <pathelement location="${ooxml.output.dir}"/>
    </path>

    <path id="test.excelant.classpath">
        <path refid="ooxml.classpath"/>
        <pathelement location="${ooxml.output.dir}"/>
        <pathelement location="${excelant.output.dir}"/>
        <pathelement location="${excelant.output.test.dir}"/>
        <pathelement location="${main.output.test.dir}"/>
        <pathelement location="${additionaljar}"/>
    </path>

    <path id="javadoc.classpath">
        <path refid="main.classpath"/>
        <path refid="scratchpad.classpath"/>
        <path refid="ooxml.classpath"/>
        <path refid="ooxml.xmlsec.classpath"/>
        <path path="${env.CLASSPATH}"/>
    </path>

    <path id="lib.jacoco">
        <fileset dir="lib">
            <include name="org.jacoco*.jar" />
            <include name="asm-all-*.jar" />
        </fileset>
    </path>

    <!-- Prints POI's Ant usage help -->
    <target name="help" description="Prints Apache POI's Ant usage help">
      <echo>
  This is POI ${version.id}
  Java Version ${ant.java.version}
  Timestamp ${DSTAMP}
  The main targets of interest are:
    - clean       Erase all build work products (ie. everything in the build directory)
    - compile     Compile all files from main, ooxml and scratchpad
    - test        Run all unit tests from main, ooxml and scratchpad
    - jar         Produce jar files
    - jar-src     Produce source-jar files
    - assemble    Produce the zipped distribution files
    - site        Generate all documentation (Requires Apache Forrest)
    - dist        Create a distribution (Requires Apache Forrest)
        </echo>
    </target>

    <tstamp>
        <format property="tstamp.year" pattern="yyyy"/>
    </tstamp>

    <target name="init" depends="fetch-jars,fetch-ooxml-jars" description="Initialization run before other targets.">
        <mkdir dir="build"/>
        <mkdir dir="${main.output.dir}"/>
        <mkdir dir="${main.output.test.dir}"/>
        <mkdir dir="${main.reports.test}"/>
        <mkdir dir="${scratchpad.output.dir}"/>
        <mkdir dir="${scratchpad.output.test.dir}"/>
        <mkdir dir="${scratchpad.reports.test}"/>
        <mkdir dir="${geometry.output.tmpdir}"/>
        <mkdir dir="${ooxml.output.dir}"/>
        <mkdir dir="${ooxml.output.test.dir}"/>
        <mkdir dir="${ooxml.reports.test}"/>
        <mkdir dir="${excelant.output.dir}"/>
        <mkdir dir="${excelant.output.test.dir}"/>
        <mkdir dir="${excelant.reports.test}"/>
        <mkdir dir="${examples.output.dir}"/>
        <mkdir dir="${integration.output.test.dir}"/>
        <mkdir dir="${integration.reports.test}"/>
        <mkdir dir="${dist.dir}"/>
        <mkdir dir="${build.site}"/>

        <echo message="Using Java: ${java.version}/${java.runtime.version}/${java.vm.version}/${java.vm.name} from ${java.vm.vendor} on ${os.name}: ${os.version}" />
    </target>

    <target name="clean" description="Remove generated artefacts">
        <delete dir="build"/>
    </target>

    <target name="testexist">
        <echo message="Testing  for ${destfile}" level="debug"/>
        <available file="${destfile}" property="exist"/>
    </target>
    <target name="downloadfile" unless="exist" depends="testexist">
        <get src="${sourcefile}" dest="${destfile}"/>
    </target>

    <target name="check-jars">
        <!-- remove previous versions of third-party jars to prevent them from lingering around,
            we often had hard-to-find build/CI-problems because of these! -->
        <mkdir dir="${main.lib}"/>
        <mkdir dir="${compile.lib}"/>
        <mkdir dir="${ooxml.lib}"/>
        <delete verbose="true">
            <fileset dir="${main.lib}">
                <include name="ant-1.8*"/>
                <include name="asm-all-4*"/>
                <include name="commons-codec-1.5*"/>
                <include name="commons-codec-1.9*"/>
                <include name="commons-logging-1.1*.jar"/>
                <include name="jacoco-0.6*"/>
                <include name="jacoco-0.7.1*"/>
                <include name="jacoco-0.7.2*"/>
                <include name="jacoco-0.7.3*"/>
                <include name="log4j-1.2.13*"/>
                <include name="org.jacoco.*-0.6.*"/>
                <include name="org.jacoco.*-0.7.1*"/>
                <include name="org.jacoco.*-0.7.2*"/>
                <include name="org.jacoco.*-0.7.3*"/>
                <include name="dom4j*"/>
                <include name="apache-rat-0.10*"/>
                <include name="xercesImpl-*.jar"/>
                <include name="junit-3*"/>
                <include name="junit-4.11*"/>
            	<include name="forbiddenapis-1.*.jar"/>
            </fileset>
        	<fileset dir="${ooxml.lib}">
        		<include name="ooxml-schemas-1.1-sources.jar"/>
        		<include name="ooxml-schemas-src-1.1.jar"/>
        		<include name="ooxml-schemas-1.1.jar"/>
        	</fileset>
        	<fileset dir="${compile.lib}">
                <include name="xercesImpl-*.jar"/>
            	<include name="xmlsec-2.0.1.jar"/>
            	<include name="bcprov-ext-jdk15on-1.51.jar"/>
            	<include name="bcpkix-jdk15on-1.51.jar"/>
            	<include name="slf4j-api-1.7.7.jar"/>
        	</fileset>
        </delete>

        <condition property="jars.present">
            <or>
                <and>
                    <available file="${main.commons-logging.jar}"/>
                    <available file="${main.commons-codec.jar}"/>
                    <available file="${main.log4j.jar}"/>
                    <available file="${main.junit.jar}"/>
                    <available file="${main.hamcrest.jar}"/>
                    <available file="${main.ant.jar}"/>
                    <available file="${main.antlauncher.jar}"/>
                    <available file="${asm.jar}"/>
                    <available file="${jacoco.zip}"/>
                    <available file="${rat.jar}"/>
                    <available file="${forbidden.jar}"/>
                    <available file="${dsig.bouncycastle-prov.jar}"/>
                    <available file="${dsig.bouncycastle-pkix.jar}"/>
                    <available file="${dsig.xmlsec.jar}"/>
                    <available file="${dsig.sl4j-api.jar}"/>
                </and>
                <isset property="disconnected"/>
            </or>
        </condition>
    </target>

    <target name="fetch-jars" depends="check-jars" unless="jars.present"
            description="Fetches needed JAR files from the Internet">
        <mkdir dir="${main.lib}"/>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.commons-logging.url}"/>
            <param name="destfile" value="${main.commons-logging.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.commons-codec.url}"/>
            <param name="destfile" value="${main.commons-codec.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.log4j.url}"/>
            <param name="destfile" value="${main.log4j.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.junit.url}"/>
            <param name="destfile" value="${main.junit.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.hamcrest.url}"/>
            <param name="destfile" value="${main.hamcrest.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.ant.url}"/>
            <param name="destfile" value="${main.ant.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${main.antlauncher.url}"/>
            <param name="destfile" value="${main.antlauncher.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${asm.url}"/>
            <param name="destfile" value="${asm.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${jacoco.url}"/>
            <param name="destfile" value="${jacoco.zip}"/>
        </antcall>
        <unzip src="${jacoco.zip}" dest=".">
            <patternset>
                <include name="lib/*.jar"/>
            </patternset>
        </unzip>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${rat.url}"/>
            <param name="destfile" value="${rat.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${forbidden.url}"/>
            <param name="destfile" value="${forbidden.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${dsig.bouncycastle-prov.url}"/>
            <param name="destfile" value="${dsig.bouncycastle-prov.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${dsig.bouncycastle-pkix.url}"/>
            <param name="destfile" value="${dsig.bouncycastle-pkix.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${dsig.xmlsec.url}"/>
            <param name="destfile" value="${dsig.xmlsec.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${dsig.sl4j-api.url}"/>
            <param name="destfile" value="${dsig.sl4j-api.jar}"/>
        </antcall>
    </target>

    <target name="check-ooxml-jars">
        <condition property="ooxml.jars.present">
            <or>
                <and>
                    <available file="${ooxml.curvesapi.jar}"/>
                    <available file="${ooxml.xmlbeans23.jar}"/>
                    <available file="${ooxml.xmlbeans26.jar}"/>
                </and>
                <isset property="disconnected"/>
            </or>
        </condition>
    </target>
    <target name="fetch-ooxml-jars" depends="check-ooxml-jars" unless="ooxml.jars.present">
        <mkdir dir="${ooxml.lib}"/>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${ooxml.curvesapi.url}"/>
            <param name="destfile" value="${ooxml.curvesapi.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${ooxml.xmlbeans23.url}"/>
            <param name="destfile" value="${ooxml.xmlbeans23.jar}"/>
        </antcall>
        <antcall target="downloadfile">
            <param name="sourcefile" value="${ooxml.xmlbeans26.url}"/>
            <param name="destfile" value="${ooxml.xmlbeans26.jar}"/>
        </antcall>
    </target>

    <target name="check-ooxml-xsds">
        <condition property="ooxml-xsds.present">
            <or>
                <and>
                    <available file="${ooxml.lib}/${ooxml.xsds.izip.1}"/>
                    <available file="${ooxml.lib}/${ooxml.xsds.izip.2}"/>
                </and>
                <isset property="disconnected"/>
            </or>
        </condition>
    </target>
    <target name="fetch-ooxml-xsds" unless="ooxml-xsds.present"
        depends="check-ooxml-xsds"
            description="Fetches needed OOXML xsd files from the Internet">
        <get dest="${ooxml.lib}" skipexisting="true">
            <url url="${ooxml.xsds.url.1}"/>
            <url url="${ooxml.xsds.url.2}"/>
            <url url="${ooxml.xsds.dc.1}"/>
            <url url="${ooxml.xsds.dc.2}"/>
            <url url="${ooxml.xsds.dc.3}"/>
            <url url="${ooxml.xsds.dsig.1}"/>
            <url url="${ooxml.xsds.dsig.2}"/>
            <url url="${ooxml.xsds.dsig.3}"/>
            <chainedmapper>
                <flattenmapper/>
                <firstmatchmapper>
                    <globmapper from="Office%20Open%20XML%201st%20edition%20Part%20*%20(PDF).zip" to="OfficeOpenXML-Part*.zip"/>
                    <identitymapper/>
                </firstmatchmapper>
            </chainedmapper>
        </get>
        <unzip src="${ooxml.lib}/${ooxml.xsds.ozip.1}" dest="${ooxml.lib}">
            <fileset dir="${ooxml.lib}" includes="OfficeOpenXML-Part*.zip"/>
            <patternset>
                <include name="${ooxml.xsds.izip.1}"/>
                <include name="${ooxml.xsds.izip.2}"/>
            </patternset>
        </unzip>
    </target>
    <target name="check-compiled-ooxml-xsds" depends="fetch-ooxml-xsds">
        <condition property="ooxml-compiled-xsds.present">
            <or>
                <and>
                    <available file="${ooxml.xsds.jar}"/>
                    <available file="${ooxml.security.jar}"/>
                    <available file="${ooxml.xsds.src.jar}"/>
                    <available file="${ooxml.security.src.jar}"/>
                </and>
                <isset property="disconnected"/>
            </or>
        </condition>
    </target>
    <target name="compile-ooxml-xsds" unless="ooxml-compiled-xsds.present"
        depends="init,check-compiled-ooxml-xsds"
        description="Unpacks the OOXML xsd files, and compiles them into XmlBeans">
        <taskdef name="xmlbean"
                 classname="org.apache.xmlbeans.impl.tool.XMLBean"
                 classpath="${ooxml.xmlbeans23.jar}"/>

        <!-- We need a fair amount of memory to compile the xml schema, -->
        <!--  but limit it in case it goes wrong! -->
        <!-- Pick the right amount based on 32 vs 64 bit jvm -->
        <condition property="ooxml.memory" value="768m" else="512m">
           <equals arg1="${sun.arch.data.model}" arg2="64" />
        </condition>

        <property name="ooxml.xsds.tmp.dir" location="build/ooxml-xsds"/>
        <mkdir dir="${ooxml.xsds.tmp.dir}"/>
        <unzip src="${ooxml.lib}/${ooxml.xsds.izip.1}" dest="${ooxml.xsds.tmp.dir}"/>
        <copy todir="${ooxml.xsds.tmp.dir}">
            <fileset dir="${ooxml.visio.xsd.dir}"/>
        </copy>
        <xmlbean
                schema="${ooxml.xsds.tmp.dir}"
                srcgendir="${ooxml.xsds.src.dir}"
                optimize="yes"
                destfile="${ooxml.xsds.jar}"
                javasource="1.5"
                failonerror="true"
                fork="true"
                memoryMaximumSize="${ooxml.memory}"
                >
            <classpath refid="ooxml.classpath"/>
        </xmlbean>

        <!-- Now make a jar of the schema sources -->
        <jar
                basedir="${ooxml.xsds.src.dir}"
                destfile="${ooxml.xsds.src.jar}"
                />

        <!-- Now do the same for the security schemas -->
        <property name="ooxml.enc.xsds.tmp.dir" location="build/ooxml-security-xsds"/>
        <mkdir dir="${ooxml.enc.xsds.tmp.dir}"/>
        <unzip src="${ooxml.lib}/${ooxml.xsds.izip.2}" dest="${ooxml.enc.xsds.tmp.dir}"/>

        <copy todir="${ooxml.enc.xsds.tmp.dir}">
            <fileset dir="${ooxml.lib}" includes="dc*.xsd,xmldsig*.xsd,XAdES*.xsd"/>
            <fileset dir="${ooxml.security.xsd.dir}"/>
        </copy>

        <!-- noupa/nopvr is set because of the dublincore schemas -->
        <!-- https://issues.apache.org/jira/browse/XMLBEANS-340 -->
        <!-- javasource > 1.5 will not generate all array accessor -->
        <xmlbean
                schema="${ooxml.enc.xsds.tmp.dir}"
                srcgendir="${ooxml.security.src.dir}"
                optimize="yes"
                destfile="${ooxml.security.jar}"
                javasource="1.5"
                failonerror="true"
                fork="true"
                memoryMaximumSize="${ooxml.memory}"
                noupa="true"
                nopvr="true"
                >
            <classpath refid="ooxml.classpath"/>
        </xmlbean>

        <jar
                basedir="${ooxml.security.src.dir}"
                destfile="${ooxml.security.src.jar}"
                />
    </target>

    <target name="compile" depends="init, compile-main,
            compile-scratchpad, compile-examples, compile-excelant"
            description="Compiles the POI main classes, scratchpad and examples"/>

    <target name="compile-all" depends="compile,compile-ooxml-lite"/>

    <target name="compile-main" depends="init">
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${main.output.dir}"
               srcdir="${main.src}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath refid="main.classpath"/>
        </javac>
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${main.output.test.dir}"
               srcdir="${main.src.test}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="main.classpath"/>
                <pathelement path="${main.output.dir}"/>
            </classpath>
        </javac>
        <copy todir="${main.output.dir}">
            <fileset dir="${main.resource1.dir}"/>
        </copy>
    </target>

    <target name="generate-geometry" depends="fetch-ooxml-xsds" if="ignoreme">
        <delete dir="${geometry.output.tmpdir}"/>
        <!-- taskdef xjc -->
        <!-- "D:\Program Files\Java\jdk1.6.0_45\bin\xjc" -p org.apache.poi.sl.model.geom.binding -readOnly -Xlocator -mark-generated ooxml-schemas\dml-shapeGeometry.xsd -->
        <unzip src="${ooxml.lib}/${ooxml.xsds.izip.1}" dest="${geometry.output.tmpdir}"/>
        <exec executable="${env.JAVA_HOME}/bin/xjc">
            <arg value="-p"/>
            <arg value="${geometry.pkg}"/>
            <arg value="-b"/>
            <arg file="src/types/definitions/dml-shapeGeometry.xjb"/>
            <arg value="-readOnly"/>
            <arg value="-npa"/>
            <arg value="-no-header"/>
            <!--arg value="-mark-generated"/ -->
            <!--arg value="-Xlocator"/ -->
            <arg file="${geometry.output.tmpdir}/dml-shapeGeometry.xsd"/>
            <arg value="-d"/>
            <arg file="${geometry.output.tmpdir}"/>
        </exec>
        <copy file="src/java/org/apache/poi/POIDocument.java" tofile="${geometry.output.tmpdir}/apache-license.txt">
            <filterchain>
            <headfilter lines="16"/>
            </filterchain>
        </copy>
        <copy todir="${main.src}">
            <fileset dir="${geometry.output.tmpdir}" includes="**/*.java"/>
             <filterchain>
                 <concatfilter prepend="${geometry.output.tmpdir}/apache-license.txt"/>
             </filterchain>
        </copy>
    </target>

    <target name="compile-scratchpad" depends="compile-main,generate-geometry">
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${scratchpad.output.dir}"
               srcdir="${scratchpad.src}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath refid="scratchpad.classpath"/>
        </javac>
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${scratchpad.output.test.dir}"
               srcdir="${scratchpad.src.test}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="scratchpad.classpath"/>
                <pathelement location="${scratchpad.output.dir}"/>
                <pathelement location="${main.output.test.dir}"/>
            </classpath>
        </javac>
        <copy todir="${scratchpad.output.dir}">
            <fileset dir="${scratchpad.resource1.dir}"/>
        </copy>
    </target>

    <target name="compile-examples" depends="compile-main,compile-scratchpad,compile-ooxml">
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${examples.output.dir}"
               srcdir="${examples.src}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="ooxml.classpath"/>
                <pathelement path="${ooxml.output.dir}"/>
            </classpath>
        </javac>
        <copy todir="${examples.output.dir}">
          <fileset dir="${examples.src}">
            <include name="**/*.css"/>
          </fileset>
        </copy>
    </target>

    <target name="compile-ooxml" depends="compile-main,compile-scratchpad,compile-ooxml-xsds">
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${ooxml.output.dir}"
               srcdir="${ooxml.src}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="ooxml.classpath"/>
                <path refid="ooxml.xmlsec.classpath"/>
            </classpath>
        </javac>
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${ooxml.output.test.dir}"
               srcdir="${ooxml.src.test}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="ooxml.classpath"/>
                <path refid="ooxml.xmlsec.classpath"/>
                <path refid="test.ooxml.classpath"/>
                <pathelement path="${ooxml.output.dir}"/>
                <pathelement path="${main.output.test.dir}"/>
            </classpath>
        </javac>
        <copy todir="${ooxml.output.dir}">
            <fileset dir="${ooxml.resource1.dir}"/>
        </copy>
    </target>

    <target name="compile-excelant" depends="compile-main,compile-ooxml">
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${excelant.output.dir}"
               srcdir="${excelant.src}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath refid="excelant.classpath"/>
        </javac>
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${excelant.output.test.dir}"
               srcdir="${excelant.src.test}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="excelant.classpath"/>
                <pathelement location="${excelant.output.dir}"/>
                <pathelement path="${main.output.test.dir}"/>
            </classpath>
        </javac>
        <copy todir="${excelant.output.dir}">
            <fileset dir="${excelant.resource.dir}"/>
        </copy>
    </target>

    <target name="compile-integration" depends="compile-scratchpad, compile-main, compile-ooxml">
        <javac target="${jdk.version.class}"
               source="${jdk.version.source}"
               destdir="${integration.output.test.dir}"
               srcdir="${integration.src.test}"
               debug="${compile.debug}"
               encoding="${java.source.encoding}"
               fork="yes"
               includeantruntime="false">
            <classpath>
                <path refid="scratchpad.classpath"/>
                <path refid="ooxml.classpath"/>
                <pathelement location="${ooxml.output.dir}"/>
                <pathelement location="${main.output.test.dir}"/>
                <pathelement location="${main.ant.jar}"/>
            </classpath>
        </javac>
        <!--copy todir="${integration.output.dir}">
            <fileset dir="${integration.resource1.dir}"/>
        </copy-->
    </target>

    <target name="compile-version" depends="init"
            description="Compiles the version class">
        <!-- Generate the .java file -->
        <property name="version.java" value="${main.output.dir}/org/apache/poi/Version.java"/>
        <delete file="${version.java}"/>
        <copy
                file="src/resources/version/Version.java.template"
                tofile="${version.java}">
            <filterset>
                <filter token="VERSION" value="${version.id}"/>
                <filter token="DSTAMP" value="${DSTAMP}"/>
            </filterset>
        </copy>

        <!-- Compile -->
        <javac target="${jdk.version.class}" source="${jdk.version.source}"
               failonerror="true" destdir="${main.output.dir}" debug="on" fork="yes"
               srcdir="${main.output.dir}"
               encoding="${java.source.encoding}" includeantruntime="false">
        </javac>
        <!-- Tidy up -->
        <delete file="${version.java}"/>
    </target>

    <target name="jacocotask" depends="">
        <echo message="Coverage reporting: ${coverage.enabled}"/>
        <taskdef uri="antlib:org.jacoco.ant" resource="org/jacoco/ant/antlib.xml">
            <classpath refid="lib.jacoco"/>
        </taskdef>
    </target>

    <target name="test" depends="compile,jacocotask,test-main,test-scratchpad,test-ooxml,test-excelant"
            description="Tests main, scratchpad and ooxml"/>
    <target name="test-all" depends="test,test-ooxml-lite,testcoveragereport"/>

    <target name="testcoveragereport" depends="jacocotask" description="create test-report" xmlns:jacoco="antlib:org.jacoco.ant" if="coverage.enabled">
        <delete dir="${coverage.dir}"/>
        <mkdir dir="${coverage.dir}"/>

        <jacoco:report>
            <executiondata>
                <fileset dir="build">
                    <include name="*.exec"/>
                </fileset>
            </executiondata>

            <structure name="Apache POI">
                <group name="Main">
                    <classfiles>
                        <fileset dir="${main.output.dir}">
                            <!-- exclude large test-class -->
                            <exclude name="org/apache/poi/hssf/usermodel/DummyGraphics2d.class"/>
                        </fileset>
                    </classfiles>
                    <sourcefiles encoding="UTF-8">
                        <fileset dir="${main.src}"/>
                    </sourcefiles>
                </group>
                <group name="Scratchpad">
                    <classfiles>
                        <fileset dir="${scratchpad.output.dir}">
                            <!-- exclude some generated classes -->
                            <exclude name="org/apache/poi/hwpf/model/types/*.class"/>
                            <exclude name="org/apache/poi/hdf/model/hdftypes/definitions/*.class"/>
                        </fileset>
                    </classfiles>
                    <sourcefiles encoding="UTF-8">
                        <fileset dir="${scratchpad.src}"/>
                    </sourcefiles>
                </group>
                <group name="OOXML">
                    <classfiles>
                        <fileset dir="${ooxml.output.dir}"/>
                        <!-- there are no actual POI classes in build/ooxml-lite-classes, only generated code...
                        fileset dir="${ooxml.lite.output.dir}">
                            <exclude name="org/openxmlformats/**"/>
                            <exclude name="schema*/**"/>
                            <exclude name="org/etsi/**"/>
                            <exclude name="org/w3/**"/>
                            <exclude name="com/**"/>
                        </fileset-->
                    </classfiles>
                    <sourcefiles encoding="UTF-8">
                        <fileset dir="${ooxml.src}"/>
                        <!--fileset dir="${ooxml.lite.src}"/-->
                    </sourcefiles>
                </group>
                <group name="Excelant">
                    <classfiles>
                        <fileset dir="${excelant.output.dir}"/>
                    </classfiles>
                    <sourcefiles encoding="UTF-8">
                        <fileset dir="${excelant.src}"/>
                    </sourcefiles>
                </group>
                <!--group name="Examples">
                    <classfiles>
                        <fileset dir="${examples.output.dir}"/>
                    </classfiles>
                    <sourcefiles encoding="UTF-8">
                        <fileset dir="${examples.src}"/>
                    </sourcefiles>
                </group-->
            </structure>

            <html destdir="${coverage.dir}"/>
            <xml destfile="${coverage.dir}/coverage.xml"/>
        </jacoco:report>

        <echo message="Coverage results are available at ${coverage.dir}/index.html, ${coverage.dir}/coverage.xml" />
    </target>

    <target name="-test-main-check">
        <uptodate property="main.test.notRequired" targetfile="${main.testokfile}">
            <srcfiles dir="${main.src}"/>
            <srcfiles dir="${main.src.test}"/>
        </uptodate>
    </target>

    <target name="test-main" unless="main.test.notRequired"
            depends="compile-main, -test-main-check,jacocotask" xmlns:jacoco="antlib:org.jacoco.ant">
        <jacoco:coverage enabled="${coverage.enabled}" excludes="${coverage.excludes}" destfile="build/jacoco-main.exec">
            <junit fork="yes" forkmode="once" printsummary="yes" haltonfailure="${halt.on.test.failure}"
                   failureproperty="main.test.failed" showoutput="true">
                <classpath refid="test.classpath"/>
                <syspropertyset refid="junit.properties"/>
                <jvmarg value="-ea"/>
                <jvmarg value="-Xmx256m"/>
            	<!-- jvmarg value="-Duser.timezone=UTC"/ -->
                <formatter type="plain"/>
                <formatter type="xml"/>
                <batchtest todir="${main.reports.test}">
                    <fileset dir="${main.src.test}">
                        <include name="**/${testpattern}.java"/>
                        <exclude name="**/All*Tests.java"/>
                        <exclude name="**/TestUnfixedBugs.java"/>
                        <exclude name="**/TestcaseRecordInputStream.java"/>
                    </fileset>
                </batchtest>
            </junit>
        </jacoco:coverage>
        <delete file="${main.testokfile}"/>
        <antcall target="-test-main-write-testfile"/>
    </target>

    <target name="-test-property-check" unless="testcase">
        <echo message="Please use -Dtestcase=org.your.testcase to run a single test"/>
        <fail/>
    </target>

    <target name="-test-main-write-testfile" unless="main.test.failed">
        <echo file="${main.testokfile}" append="false" message="testok"/>
    </target>

    <target name="-test-scratchpad-check">
        <uptodate property="scratchpad.test.notRequired" targetfile="${scratchpad.testokfile}">
            <srcfiles dir="${scratchpad.src}"/>
            <srcfiles dir="${scratchpad.src.test}"/>
        </uptodate>
    </target>

    <target name="test-scratchpad" depends="compile-main,compile-scratchpad,-test-scratchpad-check,jacocotask,test-scratchpad-download-resources"
            unless="scratchpad.test.notRequired" xmlns:jacoco="antlib:org.jacoco.ant">
        <jacoco:coverage enabled="${coverage.enabled}" excludes="${coverage.excludes}" destfile="build/jacoco-scratchpad.exec">
            <junit printsummary="yes" fork="yes" forkmode="once" haltonfailure="${halt.on.test.failure}"
                   failureproperty="scratchpad.test.failed">
                <classpath refid="test.scratchpad.classpath"/>
                <syspropertyset refid="junit.properties"/>
                <jvmarg value="-ea"/>
            	<!-- jvmarg value="-Duser.timezone=UTC"/ -->
                <!--
                  YK: ensure that JUnit has enough memory to run tests.
                  Without the line below tests fail on Mac OS X with jdk-1.6.26
                  and on Windows with jdk-1.5.22
                -->
                <jvmarg value="-Xmx256M"/>
                <formatter type="plain"/>
                <formatter type="xml"/>
                <batchtest todir="${scratchpad.reports.test}">
                    <fileset dir="${scratchpad.src.test}">
                        <include name="**/${testpattern}.java"/>
                        <exclude name="**/AllTests.java"/>
                    </fileset>
                </batchtest>
            </junit>
        </jacoco:coverage>
        <delete file="${scratchpad.testokfile}"/>
        <antcall target="-test-scratchpad-write-testfile"/>
    </target>

    <target name="-test-scratchpad-write-testfile" unless="scratchpad.test.failed">
        <echo file="${scratchpad.testokfile}" append="false" message="testok"/>
    </target>

    <target name="-test-ooxml-check">
        <uptodate property="ooxml.test.notRequired" targetfile="${ooxml.testokfile}">
            <srcfiles dir="${ooxml.src}"/>
            <srcfiles dir="${ooxml.src.test}"/>
        </uptodate>
    </target>

    <macrodef name="ooxml-test-runner" xmlns:jacoco="antlib:org.jacoco.ant">
        <attribute name="classpath"/>
        <attribute name="type"/>
        <sequential>
            <jacoco:coverage enabled="${coverage.enabled}" excludes="${coverage.excludes}" destfile="build/jacoco-@{type}.exec">
              <junit printsummary="yes" fork="yes" forkmode="once" haltonfailure="${halt.on.test.failure}"
                     failureproperty="ooxml.test.failed">
                  <classpath refid="@{classpath}"/>
                  <syspropertyset refid="junit.properties"/>
              	  <jvmarg value="-Xmx768M"/>
                  <jvmarg value="-ea"/>
              	  <!-- jvmarg value="-Duser.timezone=UTC"/ -->
                  <formatter type="plain"/>
                  <formatter type="xml"/>
                  <batchtest todir="${ooxml.reports.test}">
                      <fileset dir="${ooxml.src.test}">
                          <include name="**/${testpattern}.java"/>
                          <exclude name="**/TestUnfixedBugs.java"/>
                          <exclude name="**/All*Tests.java"/>
                            <exclude name="**/TestSignatureInfo.java"/>
                      </fileset>
                  </batchtest>
              </junit>
            </jacoco:coverage>
            <jacoco:coverage enabled="${coverage.enabled}" excludes="${coverage.excludes}" destfile="build/jacoco-@{type}-xmlsec.exec">
              <junit printsummary="yes" fork="yes" forkmode="once" haltonfailure="${halt.on.test.failure}"
                     failureproperty="ooxml.xmlsec.test.failed">
                  <classpath>
                      <path refid="@{classpath}"/>
                      <path refid="ooxml.xmlsec.classpath"/>
                  </classpath>
                  <syspropertyset refid="junit.properties"/>
              	  <jvmarg value="-Xmx768M"/>
                  <jvmarg value="-ea"/>
                  <formatter type="plain"/>
                  <formatter type="xml"/>
                  <batchtest todir="${ooxml.reports.test}">
                      <fileset dir="${ooxml.src.test}">
                            <include name="**/TestSignatureInfo.java"/>
                      </fileset>
                  </batchtest>
              </junit>
            </jacoco:coverage>
        </sequential>
    </macrodef>

    <target name="test-ooxml" depends="compile-main,compile-ooxml,-test-ooxml-check,jacocotask" unless="ooxml.test.notRequired">
        <ooxml-test-runner classpath="test.ooxml.classpath" type="ooxml"/>
        <delete file="${ooxml.testokfile}"/>
        <antcall target="-test-ooxml-write-testfile"/>
    </target>

    <target name="-test-ooxml-write-testfile" unless="ooxml.test.failed">
        <echo file="${ooxml.testokfile}" append="false" message="testok"/>
    </target>

    <target name="-test-integration-check">
        <uptodate property="integration.test.notRequired" targetfile="${integration.testokfile}">
            <srcfiles dir="${integration.src.test}"/>
        </uptodate>
    </target>

    <target name="test-integration" depends="compile-integration,-test-integration-check,jacocotask"
            unless="integration.test.notRequired" xmlns:jacoco="antlib:org.jacoco.ant">
        <jacoco:coverage enabled="${coverage.enabled}" excludes="${coverage.excludes}" destfile="build/jacoco-integration.exec">
            <junit printsummary="withOutAndErr" fork="yes" forkmode="once" haltonfailure="${halt.on.test.failure}"
                   failureproperty="integration.test.failed" showoutput="true">
                <classpath refid="test.integration.classpath"/>
                <syspropertyset refid="junit.properties"/>
                <jvmarg value="-ea"/>
                <!--
                  YK: ensure that JUnit has enough memory to run tests.
                  Without the line below tests fail on Mac OS X with jdk-1.6.26
                  and on Windows with jdk-1.5.22
                -->
                <jvmarg value="-Xmx1512M"/>
                <formatter type="plain"/>
                <formatter type="xml"/>
                <batchtest todir="${integration.reports.test}">
                    <fileset dir="${integration.src.test}">
                        <include name="**/${testpattern}.java"/>
                    </fileset>
                </batchtest>
            </junit>
        </jacoco:coverage>
        <delete file="${integration.testokfile}"/>
        <antcall target="-test-integration-write-testfile"/>
    </target>

    <target name="-test-integration-write-testfile" unless="integration.test.failed">
        <echo file="${integration.testokfile}" append="false" message="testok"/>
    </target>

    <target name="compile-ooxml-lite" depends="compile-ooxml">
        <property name="ooxml.lite-merged.dir" location="build/ooxml-lite-merged"/>
        <mkdir dir="${ooxml.lite-merged.dir}"/>

        <jar destfile="${ooxml.lite-merged.dir}/ooxml-lite-merged.jar">
            <zipfileset includes="**/*" src="${ooxml.xsds.jar}"/>
            <zipfileset includes="**/*" src="${ooxml.security.jar}"/>
        </jar>

        <java classname="org.apache.poi.util.OOXMLLite" fork="yes"
            failonerror="true">
            <classpath>
                <pathelement path="${ooxml.lite-merged.dir}/ooxml-lite-merged.jar"/>
            </classpath>
            <classpath refid="test.ooxml.classpath"/>
            <classpath refid="ooxml.xmlsec.classpath"/>
            <syspropertyset refid="junit.properties"/>
            <jvmarg value="-XX:MaxPermSize=256m"/>
            <jvmarg value="-Xmx512m"/>
            <arg value="-ooxml"/>
            <arg value="${ooxml.lite-merged.dir}/ooxml-lite-merged.jar"/>
            <arg value="-test"/>
            <arg value="${ooxml.output.test.dir}"/>
            <arg value="-dest"/>
            <arg value="${ooxml.lite.output.dir}"/>
        </java>
    </target>

    <target name="test-ooxml-lite" depends="jacocotask,compile-ooxml-xsds,compile-ooxml-lite">
        <delete file="${ooxml.testokfile}"/>
        <echo message="Running ooxml tests against 'poi-ooxml-schemas'"/>
        <ooxml-test-runner classpath="ooxml-lite.classpath" type="ooxml-lite"/>
    </target>

    <target name="-test-excelant-check">
        <uptodate property="excelant.test.notRequired" targetfile="${excelant.testokfile}">
            <srcfiles dir="${excelant.src}"/>
            <srcfiles dir="${excelant.src.test}"/>
        </uptodate>
    </target>

    <target name="-test-excelant-write-testfile" unless="excelant.test.failed">
        <echo file="${excelant.testokfile}" append="false" message="testok"/>
    </target>

    <target name="test-excelant" depends="compile-excelant,-test-excelant-check,jacocotask"
            unless="excelant.test.notRequired" xmlns:jacoco="antlib:org.jacoco.ant">
        <jacoco:coverage enabled="${coverage.enabled}" excludes="${coverage.excludes}" destfile="build/jacoco-excelant.exec">
            <junit printsummary="yes" fork="yes" forkmode="once" haltonfailure="${halt.on.test.failure}"
                   failureproperty="excelant.test.failed">
                <classpath refid="test.excelant.classpath"/>
                <syspropertyset refid="junit.properties"/>
                <jvmarg value="-ea"/>
                <formatter type="plain"/>
                <formatter type="xml"/>
                <batchtest todir="${excelant.reports.test}">
                    <fileset dir="${excelant.src.test}">
                        <include name="**/${testpattern}.java"/>
                    </fileset>
                </batchtest>
            </junit>
        </jacoco:coverage>
        <delete file="${excelant.testokfile}"/>
        <antcall target="-test-excelant-write-testfile"/>
    </target>



    <target name="-check-docs">
        <echo message="Checking if documentation recreation is necessary, i.e. if any file at ${main.documentation} is newer than ${build.site}/index.html"/>
        <uptodate property="main.docs.notRequired" targetfile="${build.site}/index.html">
            <srcfiles dir="${main.documentation}" />
        </uptodate>
    </target>

    <target name="-check-forrest-installed" unless="env.FORREST_HOME">
        <echo>Please install Apache Forrest (see
            &lt;http://forrest.apache.org/index.html&gt;) and set the
            FORREST_HOME environment variable!
        </echo>
        <fail message="Apache Forrest is not installed."/>
    </target>

    <target name="docs" depends="init, -check-forrest-installed, -check-docs"
            unless="main.docs.notRequired" description="Builds the POI website">

        <mkdir dir="${build.site.src}/${main.documentation}"/>
        <copy todir="${build.site.src}/${main.documentation}">
            <fileset dir="${main.documentation}"/>
        </copy>
        <copy file="forrest.properties" tofile="${build.site.src}/forrest.properties"/>

        <move
                file="${build.site.src}/src/documentation/content/xdocs/status.xml"
                tofile="${build.site.src}/status.xml"/>

        <ant antfile="${env.FORREST_HOME}/forrest.antproxy.xml" target="site">
            <property name="project.home" location="${build.site.src}"/>
        </ant>

        <echo>Broken links:</echo>
        <echo file="${build.site}/../tmp/brokenlinks.txt"/>

        <touch>
            <fileset dir="${build.site}"/>
        </touch>
    </target>

    <!-- Generates the API documentation. -->
    <target name="javadocs"
            description="Generates the API documentation">
        <javadoc verbose="false" author="true" destdir="${apidocs.report.dir}"
                 windowtitle="POI API Documentation" use="true" version="true"
                 maxmemory="384M" additionalparam="-notimestamp" locale="en_US"
                 classpathref="javadoc.classpath">
            <packageset dir="${main.src}" defaultexcludes="yes">
                <include name="org/apache/poi/**"/>
            </packageset>
            <packageset dir="${scratchpad.src}" defaultexcludes="yes">
                <include name="org/apache/poi/**"/>
                <exclude name="org/apache/poi/hdf/**"/>
            </packageset>
            <packageset dir="${ooxml.src}" defaultexcludes="yes">
                <include name="org/apache/poi/**"/>
            </packageset>

            <doctitle><![CDATA[<h1>POI API Documentation</h1>]]></doctitle>
            <bottom>
                <![CDATA[<i>Copyright ${tstamp.year} The Apache Software Foundation or
        its licensors, as applicable.</i>]]>
            </bottom>
            <group>
                <title>DDF - Dreadful Drawing Format</title>
                <package name="org.apache.poi.ddf*"/>
            </group>
            <group>
                <title>HPSF - Horrible Property Set Format</title>
                <package name="org.apache.poi.hpsf*"/>
            </group>
            <group>
                <title>HSSF - Horrible Spreadsheet Format</title>
                <package name="org.apache.poi.hssf*"/>
            </group>
            <group>
                <title>HWPF - Horrible Word Processor Format</title>
                <package name="org.apache.poi.hwpf*"/>
            </group>
            <group>
                <title>POIFS - POI File System</title>
                <package name="org.apache.poi.poifs*"/>
            </group>
            <group>
                <title>Utilities</title>
                <package name="org.apache.poi.util*"/>
            </group>
            <group>
                <title>Examples</title>
                <package name="org.apache.poi.hpsf.examples*"/>
                <package name="org.apache.poi.hssf.usermodel.examples*"/>
            </group>
        </javadoc>
    </target>


    <!-- Generates documentation and reports -->
    <target name="site" depends="docs,javadocs"
            description="Generates POI's website's contents"/>


    <target name="maven-poms"
            description="Builds the POM files for a maven distribution, and copies these and the jars to the appropriate locations">

        <!-- Build the org.apache.poi poms -->
        <copy file="maven/poi.pom" tofile="${dist.dir}/poi-${version.id}.pom">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <copy file="maven/poi-scratchpad.pom" tofile="${dist.dir}/poi-scratchpad-${version.id}.pom">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <copy file="maven/poi-ooxml.pom" tofile="${dist.dir}/poi-ooxml-${version.id}.pom">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <copy file="maven/poi-examples.pom" tofile="${dist.dir}/poi-examples-${version.id}.pom">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <copy file="maven/poi-ooxml-schemas.pom" tofile="${dist.dir}/poi-ooxml-schemas-${version.id}.pom">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <copy file="maven/poi-excelant.pom" tofile="${dist.dir}/poi-excelant-${version.id}.pom">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <copy file="maven/mvn-deploy.sh" todir="${dist.dir}">
            <filterchain>
                <replacetokens>
                    <token key="VERSION" value="${version.id}"/>
                    <token key="DSTAMP" value="${DSTAMP}"/>
                </replacetokens>
            </filterchain>
        </copy>
        <echo>Maven POMs are located in ${dist.dir}</echo>
        <echo>Use mvn-deploy.sh to deploy the artifacts in the remote repository</echo>
    </target>

    <target name="-manifest">
        <manifest file="build/poi-manifest.mf">
            <attribute name="Built-By" value="${user.name}"/>
            <attribute name="Specification-Title" value="Apache POI"/>
            <attribute name="Specification-Version" value="${version.id}"/>
            <attribute name="Specification-Vendor" value="The Apache Software Foundation"/>
            <attribute name="Implementation-Title" value="Apache POI"/>
            <attribute name="Implementation-Version" value="${version.id}"/>
            <attribute name="Implementation-Vendor-Id" value="org.apache.poi"/>
            <attribute name="Implementation-Vendor" value="The Apache Software Foundation"/>
        </manifest>
    </target>

    <target name="jar" depends="compile-all, compile-version, -manifest" description="Creates jar files for distribution">
        <jar destfile="${dist.dir}/${jar.name}-${version.id}-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${main.output.dir}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-scratchpad-${version.id}-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${scratchpad.output.dir}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-ooxml-${version.id}-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${ooxml.output.dir}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-examples-${version.id}-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${examples.output.dir}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-ooxml-schemas-${version.id}-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${ooxml.lite.output.dir}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-excelant-${version.id}-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${excelant.output.dir}"/>
            <metainf dir="legal/"/>
        </jar>
    </target>

    <target name="jar-src" depends="compile-all, compile-version, -manifest" description="Sources for Maven">
        <jar destfile="${dist.dir}/${jar.name}-${version.id}-sources-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${main.src}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-scratchpad-${version.id}-sources-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${scratchpad.src}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-ooxml-${version.id}-sources-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${ooxml.src}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-examples-${version.id}-sources-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${examples.src}"/>
            <metainf dir="legal/"/>
        </jar>
        <jar destfile="${dist.dir}/${jar.name}-excelant-${version.id}-sources-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${excelant.src}"/>
            <metainf dir="legal/"/>
        </jar>
    </target>


    <target name="-do-jar-check-javadocs-package-list">
        <condition property="javadocs.package-list.present">
            <available file="build/tmp/site/build/site/apidocs/package-list"/>
        </condition>
    </target>

    <target name="-do-jar-create-javadocs-package-list"
        depends="-do-jar-check-javadocs-package-list"
        unless="javadocs.package-list.present">
        <antcall target="javadocs"/>
    </target>


    <target name="jar-javadocs" description="JavaDocs for Maven" depends="compile,-manifest,-do-jar-create-javadocs-package-list">
        <property name="build.maven.javadocs" location="build/tmp/maven-javadocs"/>

        <!-- Build and package the main javadocs -->
        <antcall target="-do-jar-javadocs">
           <param name="srcfolder" value="${main.src}" />
           <param name="jarname" value="${jar.name}" />
        </antcall>
        <!-- Build and package the scratchpad javadocs -->
        <antcall target="-do-jar-javadocs">
           <param name="srcfolder" value="${scratchpad.src}" />
           <param name="jarname" value="${jar.name}-scratchpad" />
        </antcall>
        <!-- Build and package the ooxml javadocs -->
        <antcall target="-do-jar-javadocs">
           <param name="srcfolder" value="${ooxml.src}" />
           <param name="jarname" value="${jar.name}-ooxml" />
        </antcall>
    </target>

    <target name="-do-jar-javadocs">
        <echo message="Building ${jarname} javadocs from ${srcfolder}" />
        <delete dir="${build.maven.javadocs}"/>
        <mkdir dir="${build.maven.javadocs}"/>
        <javadoc verbose="false" author="false" destdir="${build.maven.javadocs}"
                 windowtitle="POI API Documentation" use="false" version="false"
                 maxmemory="384M" additionalparam="-notimestamp -quiet" locale="en_US"
                 classpathref="javadoc.classpath">
            <packageset dir="${srcfolder}" defaultexcludes="yes">
                <include name="org/apache/poi/**"/>
            </packageset>
            <link offline="true" href="https://poi.apache.org/apidocs" packagelistLoc="build/tmp/site/build/site/apidocs"/>
        </javadoc>
        <jar destfile="${dist.dir}/${jarname}-${version.id}-javadoc-${DSTAMP}.jar"
             manifest="build/poi-manifest.mf">
            <fileset dir="${build.maven.javadocs}"/>
            <metainf dir="legal/"/>
        </jar>
    </target>

    <target name="release-notes" depends="init">
        <copy file="src/documentation/RELEASE-NOTES.txt" todir="build/dist/">
            <filterset>
                <filter token="VERSION" value="${version.id}"/>
                <filter token="DSTAMP"  value="${DSTAMP}"/>
                <filter token="RELEASE_TAG" value="${version.rel}"/>
            </filterset>
        </copy>
    </target>

    <target name="assemble" depends="jar,jar-src,jar-javadocs">
         <!-- jars to include in binary assemblies -->
         <patternset id="bin.dist.jars">
            <include name="${jar.name}-${version.id}-${DSTAMP}.jar"/>
            <include name="${jar.name}-scratchpad-${version.id}-${DSTAMP}.jar"/>
            <include name="${jar.name}-ooxml-${version.id}-${DSTAMP}.jar"/>
            <include name="${jar.name}-examples-${version.id}-${DSTAMP}.jar"/>
            <include name="${jar.name}-ooxml-schemas-${version.id}-${DSTAMP}.jar"/>
            <include name="${jar.name}-excelant-${version.id}-${DSTAMP}.jar"/>
         </patternset>

        <!-- patterns to exclude from source assemblies -->
        <patternset id="src.dist.patterns"
            excludes="build/**,
                      dist*/**,
                      maven/**,
                      lib/**,
                      compile-lib/**,
                      ooxml-lib/**,
                      scripts/**,
                      TEST*,
                      *.ipr,
                      *.iml,
                      *.iws,
                      *.lnk,
                      *.rdf,
                      *.swp,
                      .settings/**,
                      .classpath,
                      .settings/**,
                      .project"/>

        <property name="zipdir" value="${jar.name}-${version.id}"/>

        <zip destfile="${dist.dir}/${jar.name}-bin-${version.id}-${DSTAMP}.zip">
            <zipfileset dir="legal/" prefix="${zipdir}"/>
            <zipfileset dir="${main.lib}" prefix="${zipdir}/lib">
              <include name="commons-codec-*.jar"/>
              <include name="commons-logging-*.jar"/>
              <include name="junit-*.jar"/>
              <include name="log4j-*.jar"/>
            </zipfileset>
            <zipfileset dir="${ooxml.lib}" prefix="${zipdir}/ooxml-lib">
              <include name="xmlbeans-2.6*.jar"/>
            </zipfileset>
            <zipfileset dir="${dist.dir}" prefix="${zipdir}">
                <patternset refid="bin.dist.jars"/>
            </zipfileset>
            <zipfileset dir="${build.site}" prefix="${zipdir}/docs"/>
        </zip>

        <zip destfile="${dist.dir}/${jar.name}-src-${version.id}-${DSTAMP}.zip">
            <zipfileset dir="legal/" prefix="${zipdir}" />
            <zipfileset dir="." prefix="${zipdir}">
                <patternset refid="src.dist.patterns"/>
            </zipfileset>
        </zip>

        <tar destfile="${dist.dir}/${jar.name}-bin-${version.id}-${DSTAMP}.tar.gz"
               longfile="gnu"
               compression="gzip">
            <tarfileset dir="legal/" prefix="${zipdir}"/>
            <zipfileset dir="${main.lib}" prefix="${zipdir}/lib">
              <include name="commons-codec-*.jar"/>
              <include name="commons-logging-*.jar"/>
              <include name="junit-*.jar"/>
              <include name="log4j-*.jar"/>
            </zipfileset>
            <tarfileset dir="${ooxml.lib}" prefix="${zipdir}/ooxml-lib">
              <include name="xmlbeans-2.6*.jar"/>
            </tarfileset>
            <tarfileset dir="${build.site}" prefix="${zipdir}/docs"/>
            <tarfileset dir="${dist.dir}" prefix="${zipdir}">
                <patternset refid="bin.dist.jars"/>
            </tarfileset>
        </tar>

        <tar destfile="${dist.dir}/${jar.name}-src-${version.id}-${DSTAMP}.tar.gz"
             longfile="gnu"
             compression="gzip">
            <tarfileset dir="legal/" prefix="${zipdir}" />
            <tarfileset dir="." prefix="${zipdir}">
                <patternset refid="src.dist.patterns"/>
            </tarfileset>
        </tar>

        <!-- script to create signatures and hashes -->
        <copy file="maven/multisign.sh" todir="${dist.dir}"/>

        <echo>Creating Maven POMs</echo>
        <antcall target="maven-poms"/>

        <echo>Distribution located in ${dist.dir}</echo>
        <echo>Use ${dist.dir}/multisign.sh to create md5 checksums and GPG signatures</echo>
    </target>

    <target name="osgi" depends="mvn-install">
       <echo message="Building OSGi bundle via Maven" />
       <mvn:mvn pom="osgi/pom.xml">
          <arg value="-Dpoi.version=${version.id}" />
          <arg value="install" />
       </mvn:mvn>
    </target>

    <target name="dist" depends="clean, compile-all, test-all, rat-check, forbidden-apis-check, site, jar, release-notes, assemble"
            description="Creates the entire distribution into build/dist, from scratch">
    </target>

    <target name="gump" depends="compile-all, test-all, jar"/>
    <target name="jenkins" depends="compile-all, test-all, test-integration, jar, javadocs, assemble, findbugs, release-notes, rat-check, forbidden-apis-check" description="Target run by Jenkins on a continuous basis"/>

    <available property="maven.ant.tasks.present" classname="org.apache.maven.artifact.ant.Pom"/>
    <target name="maven.ant.tasks-check">
      <fail unless="maven.ant.tasks.present">
      Maven ant tasks not found.
      Please make sure the maven-ant-tasks jar is in ANT_HOME/lib, or made
      available to Ant using other mechanisms like -lib or CLASSPATH.

      You can download the Maven Ant Tasks from http://maven.apache.org/ant-tasks/download.html
      </fail>
    </target>

    <macrodef name="m2-install">
      <attribute name="artifactId"/>

      <sequential>
        <mvn:install file="${dist.dir}/@{artifactId}-${version.id}-${DSTAMP}.jar">
          <pom file="${dist.dir}/@{artifactId}-${version.id}.pom"/>
        </mvn:install>
      </sequential>
    </macrodef>

    <target name="mvn-install" depends="maven.ant.tasks-check,jar,maven-poms" description="Install POI artifacts into the local repository. Equivalent of 'mvn install'">
      <m2-install artifactId="poi"/>
      <m2-install artifactId="poi-scratchpad"/>
      <m2-install artifactId="poi-ooxml"/>
      <m2-install artifactId="poi-examples"/>
      <m2-install artifactId="poi-ooxml-schemas"/>
      <m2-install artifactId="poi-excelant"/>
    </target>

    <target name="rat-check" depends="init" description="Runs the Apache Creadur Rat check against the source code, to spot any files which are missing the correct license headers">
       <mkdir dir="${rat.reportdir}" />

       <typedef resource="org/apache/rat/anttasks/antlib.xml"
             uri="antlib:org.apache.rat.anttasks"
             classpath="${rat.jar}" />
       <rat:report xmlns:rat="antlib:org.apache.rat.anttasks" reportFile="${rat.report}">
           <fileset dir="src/">
              <exclude name="documentation/*.txt" />
              <exclude name="documentation/content/xdocs/dtd/" />
              <exclude name="documentation/content/xdocs/entity/" />
              <exclude name="scratchpad/testcases/dummy.txt" />
              <exclude name="contrib/testcases/dummy.txt" />
              <exclude name="examples/lib/dummy.txt" />
              <exclude name="resources/ooxml/org/apache/poi/xslf/usermodel/notesMaster.xml" />
              <exclude name="resources/ooxml/org/apache/poi/xslf/usermodel/empty.pptx" />
              <exclude name="resources/main/org/apache/poi/sl/draw/geom/presetShapeDefinitions.xml" />
              <exclude name="ooxml/resources/org/apache/poi/xdgf/visio.xsd" />
              <exclude name="examples/src/org/apache/poi/xslf/usermodel/pie-chart-data.txt" />
              <exclude name="**/*.iml" />
           </fileset>
       </rat:report>

       <loadfile property="rat.reportcontent" srcFile="${rat.report}"/>
       <echo>${rat.reportcontent}</echo>

       <!-- fail the build if at least one note is in the report -->
       <fail><condition><matches pattern="[1-9][0-9]* Unknown Licens" string="${rat.reportcontent}"/></condition></fail>
    </target>

    <!-- Runs the Forbiddens APIs checker against the source code, to -->
    <!--  spot any cases where we've accidently used methods we shouldn't -->
    <!-- See https://github.com/policeman-tools/forbidden-apis for details -->
    <!--  of the checks that this can do -->
    <target name="forbidden-apis-check" depends="init">
        <taskdef name="forbiddenapis" 
                 classname="de.thetaphi.forbiddenapis.ant.AntTask" 
                 classpath="${forbidden.jar}"/>
        <forbiddenapis 
                 internalRuntimeForbidden="true" 
                 classpathref="javadoc.classpath"
                 suppressAnnotation="org.apache.poi.util.SuppressForbidden"
            >
            <bundledsignatures name="jdk-unsafe-${jdk.version.source}"/>
            <bundledsignatures name="jdk-deprecated-${jdk.version.source}"/>
            <!-- 
            <bundledsignatures name="jdk-system-out"/>
            -->
            <signaturesFileset file="src/resources/devtools/forbidden-signatures.txt"/>
            <!-- sources -->
            <fileset dir="${main.output.dir}"/>
            <fileset dir="${ooxml.output.dir}"/>
            <fileset dir="${scratchpad.output.dir}"/>
            <!--
            Adding Excelant causes ClassNotFoundException, see https://github.com/policeman-tools/forbidden-apis/issues/85
            <fileset dir="${excelant.output.dir}"/>
            -->
            <!--
            <fileset dir="${examples.output.dir}"/>
            -->
            <!-- test-sources -->
            <fileset dir="${main.output.test.dir}"/>
            <fileset dir="${ooxml.output.test.dir}"/>
            <!--
            <fileset dir="${scratchpad.output.test.dir}"/>
            <fileset dir="${excelant.output.test.dir}"/>
            -->
        </forbiddenapis>
    </target>

    <target name="findbugs">
    	<!-- NOTE: we did not update to 3.x yet because it requires Java 7, but we are still supporting Java 6 currently! -->
        <antcall target="downloadfile">
            <param name="sourcefile" value="http://prdownloads.sourceforge.net/findbugs/findbugs-noUpdateChecks-2.0.3.zip?download"/>
            <param name="destfile" value="${main.lib}/findbugs-noUpdateChecks-2.0.3.zip"/>
        </antcall>

        <unzip src="${main.lib}/findbugs-noUpdateChecks-2.0.3.zip"
               dest="build/findbugs/lib">
            <patternset>
                <include name="findbugs-2.0.3/lib/**"/>
            </patternset>
            <mapper type="flatten"/>
        </unzip>

        <property name="findbugs.home" value="build/findbugs" />
        <taskdef name="findbugs" classname="edu.umd.cs.findbugs.anttask.FindBugsTask">
            <classpath>
                <fileset dir="${findbugs.home}/lib">
                    <include name="*.jar" />
                </fileset>
            </classpath>
        </taskdef>
        <findbugs home="${findbugs.home}" output="html" outputFile="build/findbugs.html"
            excludeFilter="src/resources/devtools/findbugs-filters.xml">
            <fileset dir="${dist.dir}">
                <include name="poi-${version.id}-*.jar"/>
                <include name="poi-scratchpad-${version.id}-*.jar"/>
                <include name="poi-ooxml-${version.id}-*.jar"/>
                <exclude name="poi-*${version.id}-sources-*.jar"/>
                <exclude name="poi-*${version.id}-javadocs-*.jar"/>
            </fileset>
            <auxClasspath path="${dsig.bouncycastle-pkix.jar}" />
            <auxClasspath path="${dsig.bouncycastle-prov.jar}" />
            <auxClasspath path="${dsig.sl4j-api.jar}" />
            <auxClasspath path="${dsig.xmlsec.jar}" />
            <auxClasspath path="${ooxml.xsds.jar}" />
            <auxClasspath path="${ooxml.security.jar}" />
            <auxClasspath path="${ooxml.xmlbeans26.jar}" />
            <auxClasspath path="${main.commons-codec.jar}" />
            <auxClasspath path="${main.commons-logging.jar}" />
            <auxClasspath path="${main.junit.jar}" />
            <sourcePath path="src/java" />
            <sourcePath path="src/ooxml/java" />
            <sourcePath path="src/scratchpad/src" />
        </findbugs>
        <findbugs home="${findbugs.home}" output="xml" outputFile="build/findbugs.xml"
            excludeFilter="src/resources/devtools/findbugs-filters.xml">
            <fileset dir="${dist.dir}">
                <include name="poi-${version.id}-*.jar"/>
                <include name="poi-scratchpad-${version.id}-*.jar"/>
                <include name="poi-ooxml-${version.id}-*.jar"/>
                <exclude name="poi-*${version.id}-sources-*.jar"/>
                <exclude name="poi-*${version.id}-javadocs-*.jar"/>
            </fileset>
            <auxClasspath path="${dsig.bouncycastle-pkix.jar}" />
            <auxClasspath path="${dsig.bouncycastle-prov.jar}" />
            <auxClasspath path="${dsig.sl4j-api.jar}" />
            <auxClasspath path="${dsig.xmlsec.jar}" />
            <auxClasspath path="${ooxml.xsds.jar}" />
            <auxClasspath path="${ooxml.security.jar}" />
            <auxClasspath path="${ooxml.xmlbeans26.jar}" />
            <auxClasspath path="${main.commons-codec.jar}" />
            <auxClasspath path="${main.commons-logging.jar}" />
            <auxClasspath path="${main.junit.jar}" />
            <sourcePath path="src/java" />
            <sourcePath path="src/ooxml/java" />
            <sourcePath path="src/scratchpad/src" />
        </findbugs>
    </target>

    <target name="test-scratchpad-download-resources">
        <!-- disable font downloading until TestFontRendering works on all plattforms -->
        <!-- ... eventually copy the files into the resource dirs ... -->
        <!--
        <mkdir dir="build/scratchpad-test-resources"/>

        <antcall target="downloadfile">
            <param name="sourcefile" value="http://sourceforge.net/projects/monafont/files/monafont/monafont-2.90/monafont-ttf-2.90.zip/download"/>
            <param name="destfile" value="build/scratchpad-test-resources/monafont-ttf-2.90.zip"/>
        </antcall>

        <unzip src="build/scratchpad-test-resources/monafont-ttf-2.90.zip"
               dest="build/scratchpad-test-resources">
            <patternset>
                <include name="mona.ttf"/>
            </patternset>
        </unzip>

        <antcall target="downloadfile">
            <param name="sourcefile" value="https://googlefontdirectory.googlecode.com/hg-history/c5955de4df3e40f6ab705bbccbd1f5ad93998287/cabin/Cabin-Regular.ttf"/>
            <param name="destfile" value="build/scratchpad-test-resources/Cabin-Regular.ttf"/>
        </antcall>
        -->
    </target>

</project>