ant-global.xml

<project name="ant-global" xmlns:ivy="antlib:org.apache.ivy.ant" xmlns:jacoco="antlib:org.jacoco.ant">
    <!-- Set properties that can be used in all projects. -->
    <dirname property="zimbra.root.dir" file="${ant.file.ant-global}/../"/>
    <!-- Java -->
    <property name="javac.target" value="1.8"/>
    <!-- base path for ivy cache, local repository, ant libraries, etc -->

    <property name="dev.home"  value="${user.home}"/>

    <!-- Detect if JaCoCo + ASM jars already exist -->
    <condition property="jacoco.skip">
        <and>
            <!-- JaCoCo jars renamed by retrieve step -->
            <available file="${zimbra.root.dir}/zm-zcs/lib/jacocoant.jar"/>
            <available file="${zimbra.root.dir}/zm-zcs/lib/jacocoagent.jar"/>
            <available file="${zimbra.root.dir}/zm-zcs/lib/jacococore.jar"/>
            <available file="${zimbra.root.dir}/zm-zcs/lib/jacocoreport.jar"/>
            <!-- ASM runtime jars kept with versioned names -->
            <available file="${zimbra.root.dir}/zm-zcs/lib/asm-9.5.jar"/>
            <available file="${zimbra.root.dir}/zm-zcs/lib/asm-commons-9.5.jar"/>
            <available file="${zimbra.root.dir}/zm-zcs/lib/asm-tree-9.5.jar"/>
            <available file="${zimbra.root.dir}/zm-zcs/lib/asm-util-9.5.jar"/>
        </and>
    </condition>

    <!-- Download JaCoCo libraries only if not already installed -->
    <target name="download-jacoco" depends="init-ivy" unless="jacoco.skip">
        <!-- Ensure build dir exists for ivy-jacoco.xml -->
        <mkdir dir="${build.dir}"/>
        <mkdir dir="${zimbra.root.dir}/zm-zcs/lib"/>

        <!-- Generate a temporary ivy file -->
        <echo file="${build.dir}/ivy-jacoco.xml"><![CDATA[
        <ivy-module version="2.0">
            <info organisation="zimbra" module="jacoco-temp"/>
            <dependencies>
                <!-- JaCoCo Dependencies -->
                <dependency org="org.jacoco" name="org.jacoco.ant"   rev="0.8.14"/>
                <dependency org="org.jacoco" name="org.jacoco.agent" rev="0.8.14"/>
                <dependency org="org.jacoco" name="org.jacoco.core"  rev="0.8.14"/>
                <dependency org="org.jacoco" name="org.jacoco.report" rev="0.8.14"/>
                <!-- required ASM runtime libraries -->
                <dependency org="org.ow2.asm" name="asm"         rev="9.5"/>
                <dependency org="org.ow2.asm" name="asm-commons" rev="9.5"/>
                <dependency org="org.ow2.asm" name="asm-tree"    rev="9.5"/>
                <dependency org="org.ow2.asm" name="asm-util"    rev="9.5"/>
            </dependencies>
        </ivy-module>
        ]]></echo>
              
        <!-- Resolve & download (Ivy cache avoids re-downloading on later builds) -->
        <ivy:resolve file="${build.dir}/ivy-jacoco.xml" settingsRef="dev.settings"/>
        <ivy:retrieve file="${build.dir}/ivy-jacoco.xml"
                      pattern="${zimbra.root.dir}/zm-zcs/lib/[artifact]-[revision].[ext]"
                      settingsRef="dev.settings"/>
                    
        <!-- Rename downloaded JaCoCo jars to expected names -->
        <move todir="${zimbra.root.dir}/zm-zcs/lib">
            <fileset dir="${zimbra.root.dir}/zm-zcs/lib">
                <include name="org.jacoco.*-0.8.14.jar"/>
            </fileset>
            <mapper type="regexp"
                    from="org\.jacoco\.(ant|agent|core|report)-0\.8\.14\.jar"
                    to="jacoco\1.jar"/>
        </move>
        <!-- ASM jars stay as asm-9.5.jar, asm-commons-9.5.jar, etc. -->

        <!-- Clean temp ivy file -->
        <delete file="${build.dir}/ivy-jacoco.xml" quiet="true"/>
    </target>    
    
    <target name="define-jacoco-tasks" depends="download-jacoco">
        <taskdef uri="antlib:org.jacoco.ant"
                 resource="org/jacoco/ant/antlib.xml">
            <classpath>
                <fileset dir="${zimbra.root.dir}/zm-zcs/lib">
                    <include name="jacoco*.jar"/>
                    <include name="asm-9.5.jar"/>
                    <include name="asm-commons-9.5.jar"/>
                    <include name="asm-tree-9.5.jar"/>
                    <include name="asm-util-9.5.jar"/>
                </fileset>
            </classpath>
        </taskdef>
    </target>

    <!-- Add "init-ivy" depends to your "resolve" target and the following will
         automatically download and install ivy if necessary. -->
    <property name="ivy.jar.dir" location="${dev.home}/.ant/lib" />
    <property name="ivy.install.version" value="2.3.0" />
    <property name="ivy.jar.file" value="${ivy.jar.dir}/ivy-2.3.0.jar" />
    <property name="ivy.status" value="integration" />
    <property name="ivy.organisation" value="zimbra" />
    <property name="ivy.publish.src.artifacts.pattern" value="build/[artifact]-[revision].[ext]" />
    <property name="ivy.deliver.ivy.pattern" value="${dev.home}/.zcs-deps/[organisation]/[module]/[module]-[revision].[ext]" />
    <property name="ivy.module" value="${ant.project.name}" />
    <target name="download-ivy">
      <if>
        <not>
          <available file="${ivy.jar.file}" type="file"/>
        </not>
        <then>
          <mkdir dir="${ivy.jar.dir}"/>
          <!-- download Ivy from web site so that it can be used even without any special installation. 
             Note, that 'get' task will not try downloading if this file is already downloaded. -->
          <get src="https://repo1.maven.org/maven2/org/apache/ivy/ivy/${ivy.install.version}/ivy-${ivy.install.version}.jar" 
             dest="${ivy.jar.file}" usetimestamp="true"/>  
        </then>
      </if>
    </target>

    <target name="init-ivy" depends="download-ivy">
      <!-- If ivy is not downloaded yet, try to load ivy here from ivy home. -->
        <path id="ivy.lib.path">
            <fileset dir="${ivy.jar.dir}" includes="*.jar"/>
        </path>
        <taskdef resource="org/apache/ivy/ant/antlib.xml" uri="antlib:org.apache.ivy.ant" classpathref="ivy.lib.path"/>
        <if>
          <available file="../zm-network-build" type="dir"/>
          <then>
            <ivy:settings id="dev.settings" file="../zm-network-build/ivysettings-network.xml"/>
          </then>
          <else>
            <ivy:settings id="dev.settings" file="../zm-zcs/ivysettings.xml"/>
          </else>
        </if>
    </target>
    <!-- common resolve target that should work to resolve dependencies based on ivy.xml for most projects -->
    <target name="resolve" depends="init-ivy" description="resolve dependencies">
      <ivy:resolve settingsRef="dev.settings" />
      <ivy:cachepath pathid="class.path" />
    </target>
    <!-- Ignore the classpath from the shell running ant.  This avoids dependency
      on the user's environment and suppresses the warning about includeAntRuntime. -->
    <property name="build.sysclasspath" value="ignore"/>

    <!-- Standard directory paths -->
    <property name="src.dir" location="src" />
    <property name="src.java.dir" location="src/java" />
    <property name="src.bin.dir" location="src/bin" />
    <property name="src.libexec.dir" location="src/libexec" />
    <property name="src.zimlet.dir" location="src/zimlet" />
    <property name="jars.dir" location="jars" />
    <property name="build.dir" location="build" />
    <property name="build.tmp.dir" location="${build.dir}/tmp" />
    <property name="dist.dir" location="${build.dir}/dist" />
    <property name="dist.lib.dir" location="${dist.dir}/lib"/>
    <property name="dist.lib.ext.dir" location="${dist.lib.dir}/ext"/>
    <property name="build.classes.dir" location="${build.dir}/classes" />
    <property name="build.instrumented.dir" location="${build.dir}/classes-inst" />
    <property name="build.coverage.dir" location="${build.dir}/coverage" />
    <property name="build.zimlet.dir" location="${build.dir}/zimlet" />
    <property name="test.dir" location="${build.dir}/test"/>
    <property name="itest.dir" location="${build.dir}/itest"/>
    <property name="test.src.dir" location="src/java-test"/>
    <property name="test.classes.dir" location="${build.dir}/test-classes"/>

    <path id="all.java.path">
        <pathelement location="${src.java.dir}" />
    </path>
    <!-- Standard build dependencies path -->
    <property name="build.deps.dir" location="${dev.home}/.zcs-deps"/>

    <!-- Standard install paths -->
    <property name="zimbra.home.dir" location="/opt/zimbra" />
    <property name="jetty.home.dir" location="${zimbra.home.dir}/jetty"/>
    <property name="jetty.webapps.dir" location="${jetty.home.dir}/webapps"/>
    <property name="common.jars.dir" location="${zimbra.home.dir}/lib/jars"/>
    <property name="jetty.endorsed.jars.dir" location="${jetty.home.dir}/common/endorsed"/>
    <property name="jetty.common.jars.dir" location="${jetty.home.dir}/common/lib"/>
    <property name="ext-common.jars.dir" location="${zimbra.home.dir}/lib/ext-common"/>
    <property name="common.sourcejars.dir" location="${zimbra.home.dir}/jars-src"/>

    <!-- ZimbraCommon -->
    <property name="common.dir" location="../zm-mailbox/common"/>
    <property name="common.src.java.dir" location="${common.dir}/src/java"/>
    <property name="common.classes.dir" location="${common.dir}/build/classes"/>
    <property name="common.jarfile" location="${common.dir}/build/zimbracommon.jar"/>
    <property name="common.internal.jars.dir" location="../jars-internal/jars"/>

    <!-- ZimbraNative -->
    <property name="native.dir" location="../zm-mailbox/native" />
    <property name="native.classes.dir" location="${native.dir}/build/classes" />
    <property name="native.jarfile" location="${native.dir}/build/zimbra-native.jar" />

    <!-- ZimbraServer -->
    <property name="server.dir" location="../zm-mailbox/store"/>
    <property name="server.classes.dir" location="${server.dir}/build/classes"/>
    <property name="server.test.classes.dir" location="${server.dir}/build/test-classes"/>
    <property name="server.jarfile" location="${server.dir}/build/zimbrastore.jar"/>
    <property name="server.jars.dir" location="${zimbra.home.dir}/jars"/>
    <property name="server.conf.dir" location="${server.dir}/conf"/>

    <!-- ZimbraSoap -->
    <property name="soap.dir" location="../zm-mailbox/soap"/>
    <property name="soap.classes.dir" location="${soap.dir}/build/classes"/>
    <property name="soap.jarfile" location="${soap.dir}/build/zimbrasoap.jar"/>

    <!-- ZimbraClient -->
    <property name="client.dir" location="../zm-mailbox/client"/>
    <property name="client.classes.dir" location="${client.dir}/build/classes"/>
    <property name="client.jarfile" location="${client.dir}/build/zimbraclient.jar"/>

    <!-- Classpath for running unit test, it needs classes from build dir -->
    <path id="test.class.path">
      <path refid="class.path"/>
      <pathelement location="${build.classes.dir}" />
      <pathelement location="${test.classes.dir}" />
    </path>

    <!-- Platform -->
    <condition property="native.os" value="MacOSX">
        <os name="Mac OS X"/>
    </condition>
    <condition property="native.os" value="Linux">
        <os name="Linux"/>
    </condition>
    <condition property="native.so" value="jnilib">
        <os name="Mac OS X"/>
    </condition>
    <condition property="native.so" value="so">
        <not><os name="Mac OS X"/></not>
    </condition>
    <condition property="native.arch" value="">
        <os name="Mac OS X"/>
    </condition>
    <condition property="native.arch" value=".${os.arch}">
        <not>
            <os name="Mac OS X"/>
        </not>
    </condition>
    <condition property="is-windows">
        <os family="windows"/>
    </condition>
    <condition property="is-unix">
        <not><os family="windows"/></not>
    </condition>

    <!-- Build version -->
    <taskdef resource="net/sf/antcontrib/antlib.xml">
        <classpath>
            <pathelement location="${build.deps.dir}/ant-contrib-1.0b1.jar"/>
        </classpath>
    </taskdef>
    <tstamp/>

    <condition property="zimbra.version.dir" value="${zimbra.root.dir}/zm-build/RE" else="${zimbra.root.dir}/zimbra-package-stub/version">
        <available file="${zimbra.root.dir}/zm-build/RE" type="dir"/>
    </condition>

    <condition property="zimbra.buildinfo.platform" value="${native.os}">
        <not><isset property="${zimbra.buildinfo.platform}"/></not>
    </condition>

    <loadfile property="zimbra.buildinfo.majorversion" srcFile="${zimbra.version.dir}/MAJOR">
      <filterchain>
        <striplinebreaks/>
      </filterchain>
    </loadfile>

    <loadfile property="zimbra.buildinfo.minorversion" srcFile="${zimbra.version.dir}/MINOR">
      <filterchain>
        <striplinebreaks/>
      </filterchain>
    </loadfile>

    <loadfile property="zimbra.buildinfo.microtag" srcFile="${zimbra.version.dir}/MICRO">
      <filterchain>
        <striplinebreaks/>
      </filterchain>
    </loadfile>

    <property name="zimbra.buildinfo.version" value="${zimbra.buildinfo.majorversion}.${zimbra.buildinfo.minorversion}.${zimbra.buildinfo.microtag}_${zimbra.buildinfo.buildnum}.${user.name}"/>

    <echo message="Using version from ${zimbra.version.dir}, ${zimbra.buildinfo.version}"/>

    <propertyregex property="zimbra.buildinfo.majorversion"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)"
                   select="\1"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.minorversion"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)"
                   select="\2"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.microversion"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)"
                   select="\3"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.relclass"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)_([A-Z]+)"
                   select="\4"
                   casesensitive="false" />

    <condition property="zimbra.buildinfo.relnum" value="0">
        <not><isset property="${zimbra.buildinfo.relnum}"/></not>
    </condition>

    <condition property="zimbra.buildinfo.type" value="">
        <not><isset property="${zimbra.buildinfo.type}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.release" value="${user.name}">
        <not><isset property="${zimbra.buildinfo.release}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.date" value="${DSTAMP}-${TSTAMP}">
        <not><isset property="${zimbra.buildinfo.date}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.host" value="${zimbra.server.hostname}">
        <not><isset property="${zimbra.buildinfo.host}"/></not>
    </condition>
    <property name="zimbra.buildinfo.all"
              value="Version: ${zimbra.buildinfo.version}; Type: ${zimbra.buildinfo.type}; Release: ${zimbra.buildinfo.release}; Built: ${zimbra.buildinfo.date}; Host: ${zimbra.buildinfo.host}"/>

    <target name="set-dev-version">
      <if>
        <not>
          <isset property="jar.file"/>
        </not>
        <then>
          <exec executable="git" outputproperty="git.timestamp">
            <arg value="log"/>
            <arg value="-1"/>
            <arg value="--pretty=format:%at"/>
          </exec>
          <property name="dev.version" value="${zimbra.buildinfo.majorversion}.${zimbra.buildinfo.minorversion}.${zimbra.buildinfo.microversion}.${git.timestamp}"/>
          <property name="jar.file" value="${ant.project.name}-${dev.version}.jar"/>
        </then>
      </if>
    </target>

    <target name="clean">
        <delete dir="${build.dir}"/>
        <delete dir="${dist.dir}"/>
    </target>

    <target name="build-init">
      <mkdir dir="${build.classes.dir}"/>
      <mkdir dir="${dist.dir}"/>
    </target>

    <target name="compile" depends="build-init,resolve" description="Compiles from src/java into build/classes.">
        <mkdir dir="${build.classes.dir}" />
        <javac destdir="${build.classes.dir}" debug="true" classpathref="class.path" target="${javac.target}" encoding="utf-8">
            <src refid="all.java.path" />
        </javac>
    </target>

    <target name="test-compile" unless="skipTests" depends="compile">
      <if>
        <available file="${test.src.dir}" type="dir"/>
        <then>
          <mkdir dir="${test.classes.dir}"/>
            <javac destdir="${test.classes.dir}" srcdir="${test.src.dir}" classpathref="test.class.path"
               debug="true" target="${javac.target}" encoding="utf-8" />
            <copy todir="${test.classes.dir}">
              <fileset dir="${test.src.dir}" excludes="**/*.java"/>
            </copy>
         </then>
      </if>
    </target>

    <target name="test" unless="skipTests" depends="test-compile" description="Run unit tests">
      <if>
        <available file="${test.src.dir}" type="dir"/>
        <then>
          <property name="test.path" refid="test.class.path"/>
          <delete dir="${test.dir}" quiet="true"/>
          <mkdir dir="${test.dir}/output"/>
          <mkdir dir="${test.dir}/report"/>
          <mkdir dir="${test.dir}/extensions"/>
          <move todir="${test.dir}/extensions/com/zimbra/extensions" failonerror="false">
            <fileset dir="${test.classes.dir}/com/zimbra/extensions" />
          </move>
          <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
          <junit printsummary="on" showoutput="true" failureproperty="junit.failure" tempdir="${test.dir}" fork="true">
            <classpath refid="test.class.path"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <batchtest todir="${test.dir}/output">
                <fileset dir="${test.src.dir}">
                    <include name="**/*Test.java"/>
                    <exclude name="**/*ITest.java"/>
                    <exclude name="**/Abstract*Test.java"/>
                </fileset>
            </batchtest>
          </junit>
          <junitreport todir="${test.dir}/report">
            <fileset dir="${test.dir}/output"/>
            <report todir="${test.dir}/report"/>
          </junitreport>
          <echo>Test Report: ${test.dir}/report/index.html</echo>
          <fail if="junit.failure" message="Unit test failed" unless="ignore.junit.failure"/>
        </then>
        <else>
          <echo>${test.src.dir} not found. Will not run unit tests</echo>
        </else>
      </if>
    </target>

    <target name="test-hudson" depends="test-compile" description="Run hudson unit tests">
        <property name="test.path" refid="test.class.path"/>
        <delete dir="${test.dir}" quiet="true"/>
        <mkdir dir="${test.dir}/output"/>
        <mkdir dir="${test.dir}/report"/>
        <mkdir dir="${test.dir}/extensions"/>
        <move todir="${test.dir}/extensions/com/zimbra/extensions" failonerror="false">
            <fileset dir="${test.classes.dir}/com/zimbra/extensions" />
        </move>
        <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
        <junit printsummary="on" showoutput="true" failureproperty="junit.failure" tempdir="${test.dir}">
            <classpath refid="test.class.path"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <batchtest todir="${test.dir}/output">
                <fileset dir="${test.src.dir}">
                    <include name="**/*Test.java"/>
                    <exclude name="**/*ITest.java"/>
                    <exclude name="**/Abstract*Test.java"/>
                </fileset>
            </batchtest>
        </junit>
        <junitreport todir="${test.dir}/report">
            <fileset dir="${test.dir}/output"/>
            <report todir="${test.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${test.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Unit test failed"/>
    </target>

    <!-- e.g. ant -Dtest.name=com.zimbra.cs.mailbox.ContactTest single-test -->
    <target name="single-test" depends="test-compile" description="Run single unit test">
        <fail message="test.name must be set - Need e.g. ant -Dtest.name=com.zimbra.cs.mailbox.ContactTest single-test"
              unless="test.name"/>
        <property name="single.test.dir" value="${test.dir}-${test.name}"/>
        <delete dir="${single.test.dir}" quiet="true"/>
        <mkdir dir="${single.test.dir}/output"/>
        <mkdir dir="${single.test.dir}/report"/>
        <mkdir dir="${test.dir}/extensions"/>
        <move todir="${test.dir}/extensions/com/zimbra/extensions" failonerror="false">
            <fileset dir="${test.classes.dir}/com/zimbra/extensions" />
        </move>
        <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
        <junit fork="yes" printsummary="on" showoutput="true" failureproperty="junit.failure" tempdir="${single.test.dir}">
            <classpath refid="test.class.path"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <test name="${test.name}" todir="${single.test.dir}/output" />
        </junit>
        <junitreport todir="${single.test.dir}/report">
            <fileset dir="${single.test.dir}/output"/>
            <report todir="${single.test.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${single.test.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Single Unit test failed"/>
    </target>

    <!-- coverage target -->
    <target name="coverage" depends="test-compile, define-jacoco-tasks"
            description="Run unit tests with JaCoCo instrumentation"
            unless="skipCoverage">
        <delete dir="${build.coverage.dir}" quiet="true"/>
        <mkdir dir="${build.coverage.dir}"/>
        <mkdir dir="${build.coverage.dir}/html"/>

        <!-- Capture coverage -->
        <jacoco:coverage destfile="${build.coverage.dir}/jacoco.exec">
            <junit fork="true" printsummary="on" showoutput="true"
                   tempdir="${test.dir}" failureproperty="junit.failure">
                <classpath refid="test.class.path"/>
                <assertions><enable/></assertions>
                <formatter type="plain"/>
                <batchtest todir="${test.dir}/output">
                    <fileset dir="${test.src.dir}">
                        <include name="**/*Test.java"/>
                        <exclude name="**/*ITest.java"/>
                        <exclude name="**/Abstract*Test.java"/>
                    </fileset>
                </batchtest>
            </junit>
        </jacoco:coverage>
            
        <!-- Generate JaCoCo reports -->
        <trycatch>
            <try>
                <antcall target="generate-coverage-report" inheritAll="true"/>
            </try>
            <catch>
                <echo message="Coverage report generation failed (ignored). Continuing..."/>
            </catch>
            <finally>
                <echo message="Coverage report generation completed."/>
            </finally>
        </trycatch>
        <!-- Fail build only if tests failed -->
        <fail if="junit.failure" message="Unit test failed" unless="ignore.junit.failure"/>
    </target>
    
    <!-- Helper target: Generate JaCoCo HTML/XML/CSV reports -->
    <target name="generate-coverage-report" depends="define-jacoco-tasks"
            description="Generate JaCoCo HTML/XML/CSV reports">
        <jacoco:report>
            <executiondata>
                <file file="${build.coverage.dir}/jacoco.exec"/>
            </executiondata>
            <structure name="${ant.project.name}">
                <classfiles>
                    <fileset dir="${build.classes.dir}"/>
                </classfiles>
                <sourcefiles encoding="UTF-8">
                    <fileset dir="${src.java.dir}"/>
                </sourcefiles>
            </structure>

            <html destdir="${build.coverage.dir}/html"/>
            <xml destfile="${build.coverage.dir}/report.xml"/>
            <csv destfile="${build.coverage.dir}/report.csv"/>
        </jacoco:report> 
        <echo message="coverage Report: ${build.coverage.dir}/html/index.html"/>
    </target>

    <target name="integration-test" depends="test-compile" description="Run integration tests">
        <property name="test.path" refid="class.path"/>
        <delete dir="${itest.dir}" quiet="true"/>
        <mkdir dir="${itest.dir}/output"/>
        <mkdir dir="${itest.dir}/report"/>
        <junit printsummary="on" failureproperty="junit.failure" tempdir="${itest.dir}">
            <classpath refid="class.path"/>
            <classpath path="${test.classes.dir}"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <batchtest todir="${itest.dir}/output">
                <fileset dir="${test.src.dir}">
                    <include name="**/*ITest.java"/>
                </fileset>
            </batchtest>
        </junit>
        <junitreport todir="${itest.dir}/report">
            <fileset dir="${itest.dir}/output"/>
            <report todir="${itest.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${itest.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Integration test failed"/>
    </target>

    <target name="generate-jar-version" description="Creates the Version class that prints the version of the jarfile.  This class is the Main-Class in the jarfile's manifest.">
        <fail unless="build.dir" />
        <fail unless="build.classes.dir" />

        <if>
            <not><available file="${build.dir}/buildinfo/com/zimbra/buildinfo/Version.java"/></not>
            <then>
                <mkdir dir="${build.dir}/buildinfo/com/zimbra/buildinfo"/>
                <echo file="${build.dir}/buildinfo/com/zimbra/buildinfo/Version.java">
                    package com.zimbra.buildinfo;

                    public class Version {

                    public static void main(String[] args) {
                        Package p = Version.class.getPackage();
                        System.out.println("Implementation-Title: " + p.getImplementationTitle() +
                            "\nImplementation-Version: " + p.getImplementationVersion() +
                            "\nImplementation-Vendor: " + p.getImplementationVendor() + "\n");
                        }
                    }
                </echo>
            </then>
        </if>
        <javac destdir="${build.classes.dir}" debug="true" target="${javac.target}" srcdir="${build.dir}/buildinfo" />
    </target>

    <target name="zimbra-jar" depends="generate-jar-version,set-dev-version" description="Builds a standard jar file that prints its version info when executed.  Optionally sets the Zimbra-Extension-Class attribute in the manifest if the zimbra.extension.class property is set.">
        <condition property="jar.file" value="${ant.project.name}-${dev.version}.jar">
          <not><isset property="jar.file"/></not>
        </condition>
        <fail unless="implementation.title"/>
        <if>
          <not>
            <isset property="jar.build.dir"/>
          </not>
          <then>
            <property name="jar.build.dir" value="${build.classes.dir}"/>
          </then>
        </if>
        <if>
          <not>
            <isset property="excludes"/>
          </not>
          <then>
            <property name="excludes" value=""/>
          </then>
        </if>
        <if>
          <not>
            <isset property="includes"/>
          </not>
          <then>
            <property name="includes" value=""/>
          </then>
        </if>
        <echo>building jar from ${jar.build.dir}</echo>
        <if>
            <isset property="zimbra.extension.class"/>
            <then>
            <jar destfile="${build.dir}/${jar.file}" basedir="${jar.build.dir}" includes="${includes}" excludes="${excludes}">
                <manifest>
                    <attribute name="Main-Class" value="com.zimbra.buildinfo.Version" />
                    <attribute name="Implementation-Vendor" value="Zimbra Software, LLC"/>
                    <attribute name="Implementation-Title" value="${implementation.title}"/>
                    <attribute name="Implementation-Version" value="${zimbra.buildinfo.version}"/>
                    <attribute name="Specification-Vendor" value="Zimbra Software, LLC"/>
                    <attribute name="Specification-Title" value="Zimbra Collaboration Suite"/>
                    <attribute name="Specification-Version" value="${zimbra.buildinfo.majorversion}.${zimbra.buildinfo.minorversion}.${zimbra.buildinfo.microversion}"/>
                    <attribute name="Zimbra-Extension-Class" value="${zimbra.extension.class}"/>
                </manifest>
            </jar>
            </then>
            <else>
            <jar destfile="${build.dir}/${jar.file}" basedir="${jar.build.dir}" includes="${includes}" excludes="${excludes}">
                <manifest>
                    <attribute name="Main-Class" value="com.zimbra.buildinfo.Version" />
                    <attribute name="Implementation-Vendor" value="Zimbra Software, LLC"/>
                    <attribute name="Implementation-Title" value="${implementation.title}"/>
                    <attribute name="Implementation-Version" value="${zimbra.buildinfo.version}"/>
                    <attribute name="Specification-Vendor" value="Zimbra Software, LLC"/>
                    <attribute name="Specification-Title" value="Zimbra Collaboration Suite"/>
                    <attribute name="Specification-Version" value="${zimbra.buildinfo.majorversion}.${zimbra.buildinfo.minorversion}.${zimbra.buildinfo.microversion}"/>
                </manifest>
            </jar>
            </else>
        </if>
    </target>

    <target name="zimbra-zip" depends="set-dev-version" description="Builds zip file from build directory">
      <condition property="zip.file" value="${ant.project.name}-${dev.version}.zip">
        <not><isset property="zip.file"/></not>
      </condition>

      <if>
        <not>
          <isset property="zip.build.dir"/>
        </not>
        <then>
          <property name="zip.build.dir" value="${build.dir}"/>
        </then>
      </if>
      <if>
        <not>
          <isset property="excludes"/>
        </not>
        <then>
          <property name="excludes" value="${zip.file}"/>
        </then>
      </if>
      <if>
        <not>
          <isset property="includes"/>
        </not>
        <then>
          <property name="includes" value=""/>
        </then>
      </if>

      <zip destfile="${build.dir}/${zip.file}" update="true" basedir="${zip.build.dir}" includes="${includes}" excludes="${excludes}" />
    </target>

    <target name="clean-cache" description="Delete ivy cache">
        <delete dir="${dev.home}/.ivy2/cache/zimbra/${ant.project.name}"/>
        <delete dir="${dev.home}/.zcs-deps/zimbra/${ant.project.name}"/>
        <delete>
            <fileset dir="${dev.home}/.ivy2/cache" includes="*${ant.project.name}*"/>
        </delete>
    </target>

    <target name="publish-local" depends="clean-cache,jar,set-dev-version,init-ivy">
      <ivy:publish settingsRef="dev.settings" pubrevision="${dev.version}" resolver="local" overwrite="true" />
    </target>

    <target name="zmlocalconfig">
      <echo>Running localconfig with with argument: ${localconfig-args}</echo>
      <java classname="com.zimbra.cs.localconfig.LocalConfigCLI" fork="true" classpathref="class.path" failonerror="true">
        <arg line="${localconfig-args}"/>
      </java>
    </target>
    
    <target name="dist.dependencies">
         <antcall target="depend.${ant.project.name}"/>
    </target>

    <target name="sonar-scan" unless="skipSonarScan" description="Run SonarQube analysis">

      <property environment="env"/>
      <pathconvert property="sonar.java.libraries" refid="class.path" pathsep=","/>
      <pathconvert property="sonar.java.test.libraries" refid="test.class.path" pathsep=","/>

      <fail message="SONAR_HOST_URL environment variable not set" unless="env.SONAR_HOST_URL"/>
      <fail message="SONAR_TOKEN environment variable not set" unless="env.SONAR_TOKEN"/>

      <echo message="Running SonarQube scan for ${ant.project.name}"/>

      <available file="${test.src.dir}" type="dir" property="has.test.src"/>
      <available file="${test.classes.dir}" type="dir" property="has.test.classes"/>
      <available file="${test.dir}/output" type="dir" property="has.junit.report"/>
      <available file="${build.coverage.dir}/report.xml" type="file" property="has.coverage.report"/>

      <condition property="sonar.tests.arg" value="-Dsonar.tests=${test.src.dir}" else="">
        <isset property="has.test.src"/>
      </condition>

      <condition property="sonar.test.binaries.arg" value="-Dsonar.java.test.binaries=${test.classes.dir}" else="">
        <isset property="has.test.classes"/>
      </condition>

      <condition property="sonar.test.libs.arg" value="-Dsonar.java.test.libraries=${sonar.java.test.libraries}" else="">
        <isset property="has.test.classes"/>
      </condition>

      <condition property="sonar.coverage.arg" value="-Dsonar.coverage.jacoco.xmlReportPaths=${build.coverage.dir}/report.xml" else="">
        <isset property="has.coverage.report"/>
      </condition>

      <condition property="sonar.junit.arg" value="-Dsonar.junit.reportPaths=${test.dir}/output" else="">
        <isset property="has.junit.report"/>
      </condition>

      <available file="${basedir}/src/java" type="dir" property="has.src.java"/>
      <available file="${basedir}/src" type="dir" property="has.src"/>

      <condition property="final.sonar.sources" value="src/java" else="src">
        <isset property="has.src.java"/>
      </condition>

      <exec executable="sonar-scanner" failonerror="true">
        <arg value="-Dsonar.projectKey=${ant.project.name}"/>
        <arg value="-Dsonar.projectName=${ant.project.name}"/>
        <arg value="-Dsonar.projectBaseDir=${basedir}"/>
        <arg value="-Dsonar.java.source=${javac.target}"/>
        <arg value="-Dsonar.sources=${final.sonar.sources}"/>
        <arg value="-Dsonar.java.binaries=${build.classes.dir}"/>
        <arg value="-Dsonar.java.libraries=${sonar.java.libraries}"/>
        <arg value="-Dsonar.host.url=${env.SONAR_HOST_URL}"/>
        <arg value="-Dsonar.token=${env.SONAR_TOKEN}"/>
        <arg line="${sonar.tests.arg}"/>
        <arg line="${sonar.test.binaries.arg}"/>
        <arg line="${sonar.test.libs.arg}"/>
        <arg line="${sonar.junit.arg}"/>
        <arg line="${sonar.coverage.arg}"/>
      </exec>
    </target>
</project>