<?xml version="1.0" encoding="UTF-8"?>
<!--
 ***************************************************************************************************************************
 * 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.                                              *
 ***************************************************************************************************************************
-->
<project name='Juneau' xmlns:jacoco='antlib:org.jacoco.ant' default='Juneau.Build'>
	
	<taskdef 
		uri='antlib:org.jacoco.ant' 
		resource='org/jacoco/ant/antlib.xml'
		classpath='lib/jacoco/jacocoant.jar'/>
	
	<!-- ================================================================================ -->
	<!-- Common initialization -->
	<!-- ================================================================================ -->
	<target name='Juneau.Init'>
		<tstamp/>
		<loadproperties srcFile='build.properties'/>
	
		<!-- Additional classpath -->
		<path id='classpath'>
			<pathelement path='../org.apache.juneau.releng/lib/jena/jena-core-2.7.1.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/mail.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/httpclient/httpclient-4.5.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/httpclient/httpcore-4.4.1.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/httpclient/httpmime-4.5.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/javax.servlet_2.5.0.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/jaxrs/jsr311-api-1.1.1.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/equinox/org.eclipse.osgi_3.6.50.R36x_v20120315-1500.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/equinox/org.eclipse.osgi.services_3.2.100.v20100503.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/junit/junit-4.12.jar'/>
			<pathelement path='../org.apache.juneau.releng/lib/commons-fileupload/org.apache.commons.fileupload_1.3.1.jar'/>

			<!-- Microservice jar -->
			<pathelement path='../org.apache.juneau.microservice/lib/jetty-all-8.1.0.jar'/>
		</path>
	</target>

	<!-- ================================================================================ -->
	<!-- Build -->
	<!-- ================================================================================ -->
	<target name='Juneau.Build' depends='Juneau.Init' description='Creates a new release of the product.'>
		<delete dir='build' quiet='true'/>
		<mkdir dir='build'/>
		<antcall target='Juneau.BuildJars'/>
		<antcall target='Juneau.ComponentTest'/>
		<antcall target='Juneau.BuildDoc'/>
		<antcall target='Juneau.BuildDocZip'/>
	</target>

	<!-- ================================================================================ -->
	<!-- Build the jar files -->
	<!-- ================================================================================ -->
	<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
	<target name='Juneau.BuildJars' depends='Juneau.Init' description='Build jar files.'>
		
		<delete dir='bin' quiet='true'/>
		<delete dir='build' quiet='true'/>
		
		<mkdir dir='bin/core'/>
		<mkdir dir='bin/server'/>
		<mkdir dir='bin/client'/>
		<mkdir dir='bin/microservice'/>
		<mkdir dir='bin/source'/>
		<mkdir dir='bin/all/META-INF'/>

		<mkdir dir='bin/samples'/>
		<mkdir dir='bin/core.test'/>
		<mkdir dir='bin/server.test'/>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-core.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Compiling org.apache.juneau_${version}.jar ***'/>
		
		<copy todir='bin/core'>
			<fileset dir='../org.apache.juneau/src/main/java' includes='**/*.properties'/>
			<fileset dir='../org.apache.juneau' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/core' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false'>
			<classpath refid='classpath'/>
			<src path='../org.apache.juneau/src/main/java'/>
		</javac>
		<manifest file='bin/core/META-INF/MANIFEST.MF' mode='update'>
				<attribute name='Built-By' value='${user.name}'/>
				<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar jarfile='${dir.build}/org.apache.juneau_${version}.jar' basedir='bin/core' duplicate='fail' level='9' excludes='**/proto/**' manifest='bin/core/META-INF/MANIFEST.MF'/>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-server.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Compiling org.apache.juneau.server_${version}.jar ***'/>
		
		<copy todir='bin/server'>
			<fileset dir='../org.apache.juneau.server/src/main/java' includes='**/*.properties,**/*.css,**/*.ico,com/ibm/team/juneau/server/htdocs/*'/>
			<fileset dir='../org.apache.juneau.server' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/server' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false'>
			<classpath refid='classpath'/>
			<classpath path='bin/core'/>
			<src path='../org.apache.juneau.server/src/main/java'/>
		</javac>
		<manifest file='bin/server/META-INF/MANIFEST.MF' mode='update'>
			<attribute name='Built-By' value='${user.name}'/>
			<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar jarfile='${dir.build}/org.apache.juneau.server_${version}.jar' basedir='bin/server' duplicate='fail' level='9' excludes='**/proto/**' manifest='bin/server/META-INF/MANIFEST.MF'/>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-client.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** org.apache.juneau.client_${version}.jar ***'/>
		
		<copy todir='bin/client'>
			<fileset dir='../org.apache.juneau.client/src/main/java' includes='**/*.properties'/>
			<fileset dir='../org.apache.juneau.client' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/client' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false'>
			<classpath refid='classpath'/>
			<classpath path='bin/core'/>
			<src path='../org.apache.juneau.client/src/main/java'/>
		</javac>
		<manifest file='bin/client/META-INF/MANIFEST.MF' mode='update'>
				<attribute name='Built-By' value='${user.name}'/>
				<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar jarfile='${dir.build}/org.apache.juneau.client_${version}.jar' basedir='bin/client' duplicate='fail' level='9' excludes='**/proto/**' manifest='bin/client/META-INF/MANIFEST.MF'/>
		
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-microservice.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Compiling org.apache.juneau.microservice_${version}.jar ***'/>
		
		<copy todir='bin/microservice'>
			<fileset dir='../org.apache.juneau.microservice/src/main/java' includes='**/*.properties,org/apache/juneau/microservice/resources/*.html'/>
			<fileset dir='../org.apache.juneau.microservice' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/microservice' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false'>
			<classpath refid='classpath'/>
			<classpath path='bin/core'/>
			<classpath path='bin/server'/>
			<classpath path='bin/client'/>
			<src path='../org.apache.juneau.microservice/src/main/java'/>
		</javac>
		<manifest file='bin/microservice/META-INF/MANIFEST.MF' mode='update'>
				<attribute name='Built-By' value='${user.name}'/>
				<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar jarfile='${dir.build}/org.apache.juneau.microservice_${version}.jar' basedir='bin/microservice' duplicate='fail' level='9' excludes='**/proto/**' manifest='bin/microservice/META-INF/MANIFEST.MF'/>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-all.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building juneau-all-${version}.jar ***'/>
		
		<manifest file='bin/all/META-INF/MANIFEST.MF'>
			<attribute name='Built-By' value='${user.name}'/>
			<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Name' value='Apache Juneau'/>
			<attribute name='Bundle-Vendor' value='Apache Software Foundation, Juneau'/>
			<attribute name='Bundle-SymbolicName' value='org.apache.juneau.all'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>

		<jar destfile='${dir.build}/juneau-all-${version}.jar' excludes='META-INF/*' manifest='bin/all/META-INF/MANIFEST.MF'>
			<zipgroupfileset dir='${dir.build}' includes="org.apache.juneau_${version}.jar,org.apache.juneau.server_${version}.jar,org.apache.juneau.client_${version}.jar,org.apache.juneau.microservice_${version}.jar"/>
		</jar>
		
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-all_src.zip -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building juneau-all-${version}_src.zip ***'/>
		
		<zip destfile='${dir.build}/juneau-all-${version}_src.zip'>
			<fileset dir="../org.apache.juneau/src/main/java"/>
			<fileset dir="../org.apache.juneau.server/src/main/java"/>
			<fileset dir="../org.apache.juneau.client/src/main/java"/>
			<fileset dir="../org.apache.juneau.microservice/src/main/java"/>
		</zip>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-samples.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building juneau-samples-${version}.jar ***'/>

		<copy todir='bin/samples'>
			<fileset dir='../org.apache.juneau.samples/src/main/java' includes='**/*'/>
			<fileset dir='../org.apache.juneau.samples' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/samples' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false'>
			<classpath refid='classpath'/>
			<classpath path='bin/core'/>
			<classpath path='bin/server'/>
			<classpath path='bin/client'/>
			<classpath path='bin/microservice'/>
			<src path='../org.apache.juneau.samples/src/main/java'/>
		</javac>
		<manifest file='bin/samples/META-INF/MANIFEST.MF' mode='update'>
			<attribute name='Built-By' value='${user.name}'/>
			<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar jarfile='${dir.build}/juneau-samples-${version}.jar' basedir='bin/samples' duplicate='fail' level='9' excludes='**/proto/**' manifest='bin/samples/META-INF/MANIFEST.MF'/>
		
		<jar jarfile='${dir.build}/juneau-samples-fat-${version}.jar' manifest="bin/samples/META-INF/MANIFEST.MF">
			<zipgroupfileset dir='${dir.build}' includes='juneau-all-${version}.jar,juneau-samples-${version}.jar'/>
			<zipgroupfileset dir='../org.apache.juneau.microservice/lib' includes='*.jar'/>
			<zipgroupfileset dir='lib/jena' includes='*.jar'/>
			<zipgroupfileset dir='lib/derby' includes='*.jar'/>
		</jar>
		
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-core-test.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building juneau-core-test-${version}.jar ***'/>
		<copy todir='bin/core.test'>
			<fileset dir='../org.apache.juneau/src/test/java' excludes='**/*.java'/>
			<fileset dir='../org.apache.juneau' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/core.test' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false' encoding='UTF-8'>
			<classpath refid='classpath'/>
			<classpath>
				<fileset dir='${dir.build}' includes='**/*.jar'/>
			</classpath>
			<src path='../org.apache.juneau/src/test/java'/>
		</javac>
		<manifest file='bin/core.test/META-INF/MANIFEST.MF' mode='update'>
			<attribute name='Built-By' value='${user.name}'/>
			<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar jarfile='${dir.build}/juneau-core-test-${version}.jar' basedir='bin/core.test' duplicate='fail' level='9' excludes='**/proto/**' manifest='bin/core.test/META-INF/MANIFEST.MF'/>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau-server-test.jar -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building juneau-server-test-${version}.jar ***'/>
		
		<copy todir='bin/server.test'>
			<fileset dir='../org.apache.juneau.server.test/src/main/java' excludes='**/*.java'/>
			<fileset dir='../org.apache.juneau.server.test/src/test/java' excludes='**/*.java'/>
			<fileset dir='../org.apache.juneau.server.test' includes='META-INF/*'/>
		</copy>
		<javac destdir='bin/server.test' fork='true' source='1.6' target='1.6' debug='true' includeantruntime='false' encoding='UTF-8'>
			<classpath refid='classpath'/>
			<classpath>
				<fileset dir='../org.apache.juneau.microservice/lib' includes='**/*.jar'/>
				<fileset dir='${dir.build}' includes='**/*.jar'/>
			</classpath>
			<src path='../org.apache.juneau.server.test/src/main/java'/>
			<src path='../org.apache.juneau.server.test/src/test/java'/>
		</javac>
		<manifest file='bin/server.test/META-INF/MANIFEST.MF' mode='update'>
			<attribute name='Built-By' value='${user.name}'/>
			<attribute name='Build-Date' value='${TODAY}'/>
			<attribute name='Bundle-Version' value='${version}'/>
		</manifest>
		
		<jar destfile='${dir.build}/juneau-server-test-${version}.jar' basedir='bin/server.test' excludes='META-INF/*' manifest='bin/server.test/META-INF/MANIFEST.MF'>
			<zipgroupfileset dir='${dir.build}' includes='juneau-samples-fat-${version}.jar'/>
		</jar>

		<copy file='../org.apache.juneau.server.test/juneau-server-test.cfg' todir='${dir.build}/test'/>
		
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- juneau.war -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building juneau-samples-${version}.war ***'/>
		<war destfile='${dir.build}/juneau-samples-${version}.war' webxml='../org.apache.juneau.samples/war/web.xml'>
			<lib dir='lib/commons-codec-1.9'/>
			<lib dir='lib/derby'/>
			<lib dir='lib/httpclient' includes='*.jar'/>
			<lib dir='lib/jaxrs'/>
			<lib dir='lib/jena'/>
			<lib dir='${dir.build}' includes='juneau-samples-${version}.jar,juneau-all-${version}.jar'/>
		</war>

		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- org.apache.juneau.microservice.template.zip -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building org.apache.juneau.microservice.template-${version}.zip ***'/>
		<mkdir dir="${dir.build}/org.apache.juneau.microservice.template"/>
		<copy todir='${dir.build}/org.apache.juneau.microservice.template'>
			<fileset dir='../org.apache.juneau.microservice.template' excludes='target/**'/>
		</copy>
		<copy todir='${dir.build}/org.apache.juneau.microservice.template/lib'>
			<fileset dir='${dir.build}' includes='juneau-all-${version}.jar'/>
			<fileset dir='../org.apache.juneau.microservice/lib' includes='*.jar'/>
		</copy>
		<zip basedir='${dir.build}' includes='org.apache.juneau.microservice.template/**' destfile='${dir.build}/org.apache.juneau.microservice.template-${version}.zip'/>
		<delete dir="${dir.build}/org.apache.juneau.microservice.template"/>
		
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<!-- org.apache.juneau.samples.zip -->
		<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  -->
		<echo message='*** Building org.apache.juneau.samples-${version}.zip ***'/>
		<mkdir dir="${dir.build}/org.apache.juneau.samples"/>
		<copy todir='${dir.build}/org.apache.juneau.samples'>
			<fileset dir='../org.apache.juneau.samples' excludes='target/**'/>
		</copy>
		<copy todir='${dir.build}/org.apache.juneau.samples/lib'>
			<fileset dir='${dir.build}' includes='juneau-all-${version}.jar'/>
			<fileset dir='../org.apache.juneau.microservice/lib' includes='*.jar'/>
		</copy>
		<zip basedir='${dir.build}' includes='org.apache.juneau.samples/**' destfile='${dir.build}/org.apache.juneau.samples-${version}.zip'/>
		<delete dir="${dir.build}/org.apache.juneau.samples"/>
	</target>
	
	<!-- ================================================================================ -->
	<!-- Component tests -->
	<!-- ================================================================================ -->
	<target name='Juneau.ComponentTest' depends='Juneau.Init' description='Run JUnit component tests.'>

		<delete dir='${dir.build}/test/junit' failonerror='false'/>
		<delete dir='${dir.build}/test/jacoco' failonerror='false'/>
		
		<mkdir dir='${dir.build}/test/junit/results'/>
		<mkdir dir='${dir.build}/test/junit/html'/>
		
		<echo message='*** Starting juneau-samples microservice ***'/>
		<jacoco:coverage destfile='${dir.build}/test/jacoco/jacoco2.exec' includes='org.apache.juneau.*'>
			<java jar='${dir.build}/juneau-samples-fat-${version}.jar' dir='${dir.build}' fork='true' spawn='true'/>
		</jacoco:coverage>
			
		<echo message='*** Starting juneau-server-test microservice ***'/>
		<jacoco:coverage destfile='${dir.build}/test/jacoco/jacoco3.exec' includes='org.apache.juneau.*'>
			<java jar='${dir.build}/juneau-server-test-${version}.jar' dir='${dir.build}/test' fork='true' spawn='true'/>
		</jacoco:coverage>

		<echo message='*** Running component tests ***'/>
		<jacoco:coverage destfile='${dir.build}/test/jacoco/jacoco.exec' includes='org.apache.juneau.*'>
	
		<!-- Run from project dir.  Fork=true required for dir attr. -->
		<junit printsummary='true' showoutput='true' fork='true' includeAntRuntime='true' failureproperty='TestFailed' forkmode='once'>
			<sysproperty key='JUNO_SAMPLE_URL' value='http://localhost:10000'/>
			<sysproperty key='JUNO_SERVER_TEST_URL' value='http://localhost:10001'/>
			<classpath>
				<fileset dir='lib'>
					<include name='**/*.jar' />
				</fileset>
				<fileset dir='build'>
					<include name='**/*.jar' />
				</fileset>
			</classpath>
			<batchtest todir='${dir.build}/test/junit/results' filtertrace='false'>
				<fileset dir='../org.apache.juneau/src/test/java'>
					<include name='**/CT_*.java' />
				</fileset>
				<fileset dir='../org.apache.juneau.server.test/src/test/java'>
					<include name='**/CT_*.java' />
				</fileset>
				<formatter type='xml'/>
			</batchtest>
		</junit>

		</jacoco:coverage>

		<!-- Create the JUnit report file -->
		<delete dir='${dir.build}/test/junit/html' failonerror='false' />
		<mkdir dir='${dir.build}/test/junit/html' />
		<!-- Commented out for now due to bug https://issues.apache.org/bugzilla/show_bug.cgi?id=51668 -->
		<junitreport>
			<fileset dir='${dir.build}/test/junit/results'>
				<include name='**/TEST-*.xml' />
			</fileset>
			<report format='noframes' todir='${dir.build}/test/junit/html'/>
		</junitreport>

		<echo message='*** Stopping juneau-samples microservice ***'/>
		<get src='http://127.0.0.1:10000/shutdown' dest='out.html' ignoreerrors='true'/>
		
		<echo message='*** Stopping juneau-server-test microservice ***'/>
		<get src='http://127.0.0.1:10001/shutdown' dest='out.html' ignoreerrors='true'/>

		<jacoco:report>
			<executiondata>
				<!--file file='${dir.build}/test/jacoco/jacoco.exec' /-->
				<file file='${dir.build}/test/jacoco/jacoco2.exec' />
				<file file='${dir.build}/test/jacoco/jacoco3.exec' />
			</executiondata>
			<structure name='Juneau'>
			    <group name='Core'>
					<classfiles>
						<fileset dir='${dir.build}' includes='juneau-core.jar'/>
					</classfiles>
					<sourcefiles encoding='UTF-8'>
						<fileset dir='../org.apache.juneau/src/main/java' />
					</sourcefiles>
			    </group>
			    <group name='Server'>
					<classfiles>
						<fileset dir='${dir.build}' includes='juneau-server.jar'/>
					</classfiles>
					<sourcefiles encoding='UTF-8'>
						<fileset dir='../org.apache.juneau.server/src/main/java' />
					</sourcefiles>
			    </group>
			    <group name='Client'>
					<classfiles>
						<fileset dir='${dir.build}' includes='juneau-client.jar'/>
					</classfiles>
					<sourcefiles encoding='UTF-8'>
						<fileset dir='../org.apache.juneau.client/src/main/java' />
					</sourcefiles>
			    </group>
			</structure>
			<!--  to produce reports in different formats.  -->
			<html destdir='${dir.build}/test/jacoco/results' />
			<csv destfile='${dir.build}/test/jacoco/results/report.csv' />
			<xml destfile='${dir.build}/test/jacoco/results/report.xml' />
		</jacoco:report>

		<ant target='Juneau.CtFailed'/>
		<ant target='Juneau.CtSucceeded'/>
	</target>

	<target name='Juneau.CtFailed' if='TestFailed'>
		<echo message='Juneau component testsuite run had at least one failure.'/>
	</target>

	<target name='Juneau.CtSucceeded' unless='TestFailed'>
		<echo message='Juneau component testsuite run succeeded.'/>
	</target>
	
	
	<!-- ================================================================================ -->
	<!-- Build Javadocs -->
	<!-- ================================================================================ -->
	<target name='Juneau.BuildDoc' depends='Juneau.Init' unless='Juneau.BuildDoc.Executed'>
		<!--delete dir='doc'/-->
		<echo message="Building Javadocs at ${dir.build}/javadoc"/>
		<javadoc 
				access='protected' 
				windowtitle='Juneau' 
				author='true' 
				destdir='${dir.build}/javadoc' 
				linksource='on' 
				source='1.6' 
				overview='../org.apache.juneau/src/main/java/overview.html' 
				stylesheetfile='javadoc.css'
				use='true'
				additionalparam='-sourcetab 3 -notimestamp -Xdoclint:none'
				verbose='false'
				excludepackagenames='*proto*'>
			<link href='http://docs.oracle.com/javase/7/docs/api/' />
			<link href='http://docs.oracle.com/javaee/5/api/' />
			<packageset dir='../org.apache.juneau/src/main/java'>
				<include name='org/apache/juneau/**'/>
				<exclude name='**/proto/**'/>
				<exclude name='**/internal/**'/>
			</packageset>
			<packageset dir='../org.apache.juneau.client/src/main/java'>
				<include name='org/apache/juneau/**'/>
				<exclude name='**/proto/**'/>
			</packageset>
			<packageset dir='../org.apache.juneau.server/src/main/java'>
				<include name='org/apache/juneau/**'/>
				<exclude name='**/proto/**'/>
			</packageset>
			<packageset dir='../org.apache.juneau.microservice/src/main/java'>
				<include name='org/apache/juneau/**'/>
				<exclude name='**/proto/**'/>
			</packageset>
			<classpath refid='classpath'/>
			<group title='org.apache.juneau - Core API (serializers, parsers, bean context)'>
				<package name='org.apache.juneau*'/>
			</group>
			<group title='org.apache.juneau.server - REST Server API'>
				<package name='org.apache.juneau.server*'/>
			</group>
			<group title='org.apache.juneau.client - REST Client API'>
				<package name='org.apache.juneau.client*'/>
			</group>
			<group title='org.apache.juneau.microservice - Microservice API'>
				<package name='org.apache.juneau.microservice*'/>
			</group>
		</javadoc>
		<!--java classname='org.apache.juneau.utils.LinkValidator' classpath='../org.apache.juneau.utils/bin;bin' dir='.' fork='true'>
			<arg value='doc'/>
		</java-->
		
		<property name='Juneau.BuildDoc.Executed' value='true'/>
	</target>
	

	<!-- ================================================================================ -->
	<!-- Build Javadoc zip file -->
	<!-- ================================================================================ -->
	<target name='Juneau.BuildDocZip' description='Create Javadoc archive file' depends='Juneau.BuildDoc'>

		<!-- juneau_javadocs.war -->
		<echo message='*** Building juneau-javadocs-${version}.war ***'/>
		<war destfile='${dir.build}/juneau-javadocs-${version}.war' webxml='misc/web.xml'>
			<fileset dir='${dir.build}/javadoc'/>
		</war>		
		
	</target>
</project>