build.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- Copyright (C) 2008-2013 Palo Alto Research Center, Inc.

  Part of the CCNx Java Library.

  This work is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License version 2 as published by the
  Free Software Foundation. 
  This work is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  for more details. You should have received a copy of the GNU General Public
  License along with this program; if not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  Boston, MA 02110-1301, USA.
-->

<!-- This is an ant project file, see http://ant.apache.org/ -->

<!-- NOTES
  Do not use antcall with tests that depend on ccnd, because this 
  can result in more than one ccnd being run at the same time.
  If you stick to dependencies with one level of ant the ccnd
  will never be run twice regardless of the number of test targets
  that require it.
  --> 

<project default="jar" name="java-ccnx">

	<!-- To avoid conflict with Eclipse, we build in 'build' not 'bin' -->
	
	<property name="lib" location="lib"/>
	<property name="build" location="build"/>
	<property name="src.dir" location="src/main" />
	<property name="src.test.dir" location="src/test" />
	<property name="src.systemtest.dir" location="src/systemtest" />
	<property name="jarfile-base" value="ccn.jar"/>
	<property name="jarfile" location="${jarfile-base}"/>
	<property name="testout" location="testout"/>
	<property name="testoutlog" location="testout/log"/>
	<property name="LOGDIR_KEY" value="org.ccnx.ccn.LogDir"/>
	<property name="JAVA_MEMORY" value="1g" />
	<property name="ccnd" location="../csrc/ccnd/ccnd"/>
	<property name="ccnr" location="../csrc/ccnr/ccnr"/>
	<property name="cmddir" location="../csrc/cmd"/>
	<property environment="env"/>
	<property name="showoutput" value="no"/>
	<property name="repozip" value="repotest.zip"/>
	<property name="CCND_CMD" value="../../csrc/ccnd/ccnd"/>
	<property name="CCND_DEBUG" value="87"/>
	<property name="CCND_CAP" value="50000"/>
	<property name="REPO_ROOT" value="${testout}/repotest"/>
	<property name="REPO_ROOT2" value="${testout}/repotest2"/>
	<property name="REPO_LOCAL" value="TestRepository"/>
	<property name="REPO_LOCAL_ROOT" value="repotest"/>
	<property name="REPO_GLOBAL" value="/parc.com/csl/ccn/repositories/TestRepository"/>
	<property name="repo2" value="true"/>
	<property name="USE_KEY_CONFIG_KEY" value="org.ccnx.config.UseKeyConfiguration"/>
	<property name="USE_KEY_CONFIG_VAL" value="false"/>
	<!-- to allow extra noisy logging for sync while we test it better (now switched
	  back to a normal value but left in in case it is needed) -->
    <property name="SYNC_NOISY" value="INFO"/>
	<!-- To enable remote debugging, the incantation is 
	"-Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n" -->
	<property name="DEBUG_OPTIONS" value=""/>
	<property name="TOP_DIR" value="../src/systemtest"/>
	<property name="UNIT_TOP_DIR" value="../src/test"/>
	<!-- TEST_PORT is alternative ccnd port so we can run tests
        with an isolated ccnd rather than the "live" ccnd on the machine.
        -->
	<property name="TEST_PORT" value="61999"/>
	<property name="PROTOCOL_KEY" value="ccn.agent.protocol"/>
	<property name="EXIT_ON_ERROR" value="org.ccnx.ExitOnNetworkError"/>

        <!-- Classpaths are actually defined in a separate file so 
             that it can be included by ant files of apps so they 
             don't need to separately define the classpath needed 
             for CCN lib -->

        <import file="libs.xml"/>
	<path id="classpath">
		<path refid="ccn-classpath"/>
	</path>

	<path id="classpath-run">
		<path refid="ccn-classpath-run"/>
		<pathelement location="${jarfile}"/>
	</path>

	<!-- repository directory is likely to be created by running things
        so must be excluded from jar at least -->

	<property name="build-excludes" value="bin/**, log/**, lib/**, libsrc/**, repository/**, build/**, testout/**, ktrace.out, CCN_DEBUG_DATA/**"/>

	<target name="documentation">
	  <!-- requires ant-doxygen task, see http://sourceforge.net/projects/ant-doxygen/ -->
	  <taskdef name="doxygen" classname="org.doxygen.tools.DoxygenTask"
		   classpath="lib/doxygen_ant.jar" />
		<doxygen configFilename="Doxyfile"/>
	</target>

  <target name="compile" depends="compile-main, compile-systemtest, compile-test" description="Compile the main and test classes." />

  <target name="compile-main" depends="init" description="Compile the main classes">
    <mkdir dir="${build}"/>
    <depend srcdir="${src.dir}" destdir="${build}" closure="yes"/>
    <javac destdir="${build}"
              srcdir="${src.dir}" excludes="${build-excludes}"
              includeantruntime="false"
              debug="on">
      <classpath>
        <path refid="classpath"/>
      </classpath>
    </javac>
    <copy todir="${build}">
      <fileset dir="${src.dir}" excludes="${build-excludes}, **/*.java"/>
    </copy>
  </target>

  <target name="compile-test" depends="init, compile-systemtest" description="Compile the test classes">
    <mkdir dir="${build}"/>
    <depend srcdir="${src.test.dir}" destdir="${build}" closure="yes"/>
    <javac destdir="${build}"
        srcdir="${src.test.dir}" 
        includeantruntime="false"
        excludes="${build-excludes}" debug="on">
      <classpath>
        <path refid="classpath"/>
      </classpath>
    </javac>
    <copy todir="${build}">
      <fileset dir="${src.test.dir}" excludes="${build-excludes}, **/*.java"/>
    </copy>
  </target>

  <target name="compile-systemtest" depends="init" description="Compile the system test classes">
    <mkdir dir="${build}"/>
    <depend srcdir="${src.systemtest.dir}" destdir="${build}" closure="yes"/>
    <javac destdir="${build}"
        srcdir="${src.systemtest.dir}"
        includeantruntime="false"
        excludes="${build-excludes}" debug="on">
      <classpath>
        <path refid="classpath"/>
      </classpath>
    </javac>
    <copy todir="${build}">
      <fileset dir="${src.systemtest.dir}" excludes="${build-excludes}, **/*.java"/>
    </copy>
  </target>

	<target name="jar" depends="compile" description="Produce a JAR file containing the library and test classes">
		<jar compress="true" jarfile="${jarfile}" basedir="${build}">
			<exclude name="**/.classpath"/>
			<exclude name="**/.project"/>
			<exclude name="repository/**"/>
			<exclude name="${jarfile-base}"/>
		</jar>
	</target>

	<target name="clean-documentation">
		<delete dir="doc"/>
	</target>

	<target name="clean-test">
		<delete dir="${testout}"/>
	</target>

	<target name="clean" depends="clean-test, clean-documentation">
		<delete dir="${build}"/>
	</target>

	<!-- Run targets: running components -->

    <target name="dumpclasspath" depends="jar">
        <pathconvert pathsep=":" property="classpatharg" refid="classpath-run"/>
        <echo message="${classpatharg}" file=".antclasspath"/>
    </target>
	
	<target name="ccnd">
		<mkdir dir="${testout}"/>
		<parallel failonany="true">
			<daemons>
				<echo message="Running test ccnd on port ${TEST_PORT}"/>
				<exec executable="${ccnd}" dir="${testout}" output="${testout}/TEST-ccnd-baselib.txt">
					<env key="CCN_LOCAL_PORT" value="${TEST_PORT}"/>
					<env key="CCND_CAP" value="${CCND_CAP}"/>
					<env key="CCND_DEBUG" value="${CCND_DEBUG}"/>
				</exec>
			</daemons>
                        <!-- sleep needed so parallel doesn't exit before any error from daemons is reported -->
                        <sleep seconds="1"/>
		</parallel>
	</target>

    <!-- Run a ccnd on test port but not as daemon (i.e. keep running
         even if nothing else running under ant.  This is useful
         if you need to separately start a ccnd, for instance 
         to support tests that don't work when ant runs under cygwin -->
	<target name="ccnd-testport">
		<mkdir dir="${testout}"/>
		<parallel failonany="true">
			<echo message="Running test ccnd on port ${TEST_PORT}"/>
			<exec executable="${ccnd}" dir="${testout}" output="${testout}/TEST-ccnd-baselib.txt">
				<env key="CCN_LOCAL_PORT" value="${TEST_PORT}"/>
				<env key="CCND_DEBUG" value="-1"/>
			</exec>
		</parallel>
	</target>
	
	<target name="repo" depends="ccnd, repo-start, test-repo-is-up">
	</target>

	<!-- Don't run this by itself - use target repo -->
	<target name="repo-start" depends="jar, repo-start-repov2, repo-start-repov1"/>

	<target name="repo-start-repov1" unless="${repo2}">
		<parallel>
			<echo message="Running repo version 1"/>
			<daemons>
				<java classname="org.ccnx.ccn.impl.repo.RepositoryDaemon" fork="true" failonerror="true" output = "${testout}/TEST-repo-daemon.txt" dir="${testout}">
					<classpath>
						<path refid="classpath-run" />
					</classpath>
					<sysproperty key="ccn.agent.port" value="${TEST_PORT}" />
					<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
					<sysproperty key="${EXIT_ON_ERROR}" value="true"/>

					<!-- allow debugger attachment if repo loops <jvmarg value="-Xrunjdwp:transport=dt_socket,address=25000,server=y,suspend=n" /> -->
					<arg value="-interactive" />
					<arg value="-root" />
					<arg value="${REPO_LOCAL_ROOT}" />
					<arg value="-local" />
					<arg value="${REPO_LOCAL}" />
					<arg value="-global" />
					<arg value="${REPO_GLOBAL}" />
				</java>
			</daemons>
            <!-- sleep needed so parallel doesn't exit before any error from daemons is reported -->
            <sleep seconds="1"/>
		</parallel>
	</target>

	<target name="repo-start-repov2" if="${repo2}">
        <mkdir dir="${REPO_ROOT}"/>
		<parallel>
            <echo message="Running repo version 2"/>
			<daemons>
                <exec executable="${ccnr}" dir="${REPO_ROOT}" output="${testout}/TEST-ccnr-baselib.txt">
                    <env key="CCN_LOCAL_PORT" value="${TEST_PORT}"/>
                    <env key="CCNR_GLOBAL_PREFIX" value="${REPO_GLOBAL}"/>
                </exec>
			</daemons>
            <!-- sleep needed so parallel doesn't exit before any error from daemons is reported -->
            <sleep seconds="1"/>
		</parallel>
	</target>
	
	<!-- Run this after starting repo to insure it's up before running further tests"/> -->
	<target name="test-repo-is-up" depends="jar">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/RepoInitializationTest.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>

    <!-- target for running a test repo foreground so you can run a test
	     against it in debugger -->
	<target name="run-test-repo" depends="run-test-repov2, run-test-repov1"/>

	<target name="run-test-repov1" depends="jar" unless="${repo2}">
		<echo message="Running repo version 1"/>
		<mkdir dir="${testout}"/>
		<java classname="org.ccnx.ccn.impl.repo.RepositoryDaemon" fork="true" failonerror="true" output = "${testout}/TEST-repo-daemon.txt" dir="${testout}">
			<classpath>
				<path refid="classpath-run" />
			</classpath>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<jvmarg value="-Xrunjdwp:transport=dt_socket,address=25000,server=y,suspend=n" />
			<arg value="-interactive" />
			<arg value="-root" />
			<arg value="${REPO_ROOT}" />
			<arg value="-local" />
			<arg value="${REPO_LOCAL}" />
			<arg value="-global" />
			<arg value="${REPO_GLOBAL}" />
		</java>
		<!-- sleep needed so parallel doesn't exit before any error from daemons is reported -->
		<sleep seconds="1"/>
	</target>

	<target name="run-test-repov2" depends="jar" if="${repo2}">
		<echo message="Running repo version 2"/>
        		<mkdir dir="${REPO_ROOT}"/>
                <exec executable="${ccnr}" dir="${REPO_ROOT}" output="${testout}/TEST-repo-daemon.txt" failonerror="true">
                </exec>
        <!-- sleep needed so parallel doesn't exit before any error from daemons is reported -->
        <sleep seconds="1"/>
	</target>

	<!-- test is for running all current unit tests.  It should not
         be used to run "end to end" tests, system tests, or other forms
         of validating multi-unit functionality.

         The following items apply to all checkins:
         * Every new piece of functionality requires a developer authored
         unit test, either a new test method, new assertion, or complete
         suite if required, to ensure new code is working
         * Every unit test added to the source base should be added to
         the build system unless marked as skipped
         * Every unit test should pass before you checkin and push
         * After unit tests are all passing, it is expected a developer
         will run the systemtest target and verify no new unexpected
         issues have arisen.  The QA team should be responsible for
         developing reasonable system acceptance tests.  If new tests
         are required these should be filed as a new issue in the bug
         tracker.
         * Nightly CI builds will handle a first/last line of defense
         against issues that may creep in through subsequent commits or
         those which aren't found due to developer environment.
         * These rules apply to all contributions, by core team, or from
         community.
	     -->
	<target name="unittest" depends="init, jar, test-all-units">
	</target>

	<!-- test is for running all current system tests to validate code 
	     IMPORTANT: test-repo must be run before any test that will start a repo because it
	     requires that a repo *not* be running when it starts -->
	<target name="test" depends="unittest, test-repo, test-protocol, test-impl, test-io, 
				test-security, test-udp, test-endtoend">
	</target>

	<target name="test-protocol" depends="test-protocol-without-repo, test-protocol-with-repo">
	</target>

    <target name="test-all-units" depends="compile-test">
		<mkdir dir="${testout}"/>
        <junit printsummary="yes" fork="yes" haltonfailure="no" showoutput="${showoutput}" dir="${testout}">
			<classpath>
				<path refid="classpath"/>
		        <pathelement location="${build}"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
            <test name="org.ccnx.ccn.AllTests" todir="${testout}"/>
        </junit>
    </target>	

	<target name="test-protocol-without-repo" depends="jar, ccnd">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" showoutput="${showoutput}" dir="${testout}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/protocol/*Test.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>

	<target name="test-protocol-with-repo" depends="jar, ccnd, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" showoutput="${showoutput}" dir="${testout}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="org.ccnx.ccn.LogLevel" value="FINEST"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/protocol/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>

	<target name="test-impl" depends="test-impl-without-repo, test-impl-with-repo, test-sync-without-repo, test-sync-with-repo">
	</target>
	
	<target name="test-impl-without-repo" depends="jar, ccnd">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/impl/**/*Test.class"/>
					<!-- should be profiles/**/*Test.class, but don't want to include access control yet -->
					<include name="org/ccnx/ccn/profiles/ccnd/*Test.class"/>
				    <include name="org/ccnx/ccn/profiles/nameenum/*Test.class"/>
					<include name="org/ccnx/ccn/profiles/*Test.class"/>
				    <include name="org/ccnx/ccn/profiles/search/*Test.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<target name="test-udp" depends="jar, ccnd">
			<mkdir dir="${testout}"/>
			<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
				<classpath>
					<path refid="classpath-run"/>
				</classpath>
				<formatter type="xml" usefile="true"/>
				<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
				<sysproperty key="org.ccnx.agent.protocol" value="UDP"/>
				<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
				<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
	            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
				<batchtest todir="${testout}">
					<fileset dir="${build}">
						<include name="org/ccnx/ccn/impl/NetworkTest.class"/>
					</fileset>
				</batchtest>
			</junit>
		</target>
	
	<target name="test-impl-with-repo" depends="jar, ccnd, repo, test-enumerated-name-list">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/impl/**/*TestRepo.class"/>
					<!-- should be profiles/**/*TestRepo.class, but don't want to include access control yet -->
				    <include name="org/ccnx/ccn/profiles/metadata/*TestRepo.class"/>
				    <include name="org/ccnx/ccn/profiles/search/*TestRepo.class"/>
                    <include name="org/ccnx/ccn/profiles/context/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<target name="test-sync-without-repo" depends="jar, ccnd">
		<mkdir dir="${testout}"/>
		
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
			<sysproperty key="org.ccnx.ccn.LogLevel.Sync" value="${SYNC_NOISY}"/>
			<sysproperty key="org.ccnx.ccn.LogLevel.Test" value="${SYNC_NOISY}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<env key="CCNR_DIRECTORY" value="${REPO_ROOT}"/>
			<env key="PATH" value="${env.PATH}:${cmddir}"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
                    <include name="org/ccnx/ccn/profiles/sync/*Test.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<target name="test-sync-with-repo" depends="jar, ccnd, repo" if="${repo2}">
		<mkdir dir="${testout}"/>
		
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
			<sysproperty key="org.ccnx.ccn.LogLevel.Sync" value="${SYNC_NOISY}"/>
			<sysproperty key="org.ccnx.ccn.LogLevel.Test" value="${SYNC_NOISY}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<env key="CCNR_DIRECTORY" value="${REPO_ROOT}"/>
			<env key="PATH" value="${env.PATH}:${cmddir}"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
                    <include name="org/ccnx/ccn/profiles/sync/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<target name="test-io" depends="test-io-without-repo, test-io-with-repo">
	</target>

	<target name="test-io-without-repo" depends="jar, ccnd">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/io/**/*Test.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<target name="test-io-with-repo" depends="jar, ccnd, repo">
		<mkdir dir="${testout}"/>
		 <junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
		<!--	<junit printsummary="yes" haltonfailure="yes" fork="false" forkmode="perBatch" showoutput="${showoutput}">-->
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn//io/**/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>

	<!-- This target is for debugging only -->
	<target name="test-read" depends="jar, ccnd">

		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>

			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/ReadTest.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<!-- This target is for debugging only -->
	<target name="test-blockreadwrite" depends="jar, ccnd">

		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>

			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/BlockReadWriteTest.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>

	<target name="test-benchmark" depends="jar, ccnd">

		<mkdir dir="${testout}"/>
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>

			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/BenchmarkTest.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<!-- IMPORTANT: test-repo-structure and test-repo-initial-policy must be the *first* tests in this list 
	     because they require that the repo must not have been running and subsequent tests start the repo -->
	<target name="test-repo" depends="test-repo-structure, test-repo-initial-policy, test-repo-name-responder, test-repo-initial-read, 
				test-repo-io, test-repo-checked-write">
	</target>
	
	<target name="test-enumerated-name-list" depends="jar, ccnd, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/profiles/nameenum/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>
	
	<target name="test-repo-structure" depends="jar, ccnd">
		<mkdir dir="${testout}"/>
		<delete dir="${REPO_ROOT}"/>
                <!-- Note that REPO_ROOT will be produced by the RFSTest
                     due to hard-coded file name in the test code -->
		<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}">
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/RFSTest.class"/>
					<include name="org/ccnx/ccn/repo/RepositoryInfoTest.class"/>
				</fileset>
			</batchtest>
		</junit>
	</target>
	
	<target name="test-repo-initial-policy" depends="jar, ccnd" unless="${repo2}">
        <mkdir dir="${testout}"/>
        <delete dir="${REPO_ROOT2}"/>
        <junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perBatch" dir="${testout}" showoutput="${showoutput}">
            <classpath>
                <path refid="classpath-run"/>
            </classpath>
            <formatter type="xml" usefile="true"/>
            <sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
            <sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
            <sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
            <sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
            <batchtest todir="${testout}">
                <fileset dir="${build}">
                    <include name="org/ccnx/ccn/repo/RepoInitialPolicyTest.class"/>
                </fileset>
            </batchtest>
        </junit>
    </target>
	
	<target name="test-repo-initial-read" depends="jar, test-repo-structure, ccnd, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/RepoInitialReadTest.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>
	
	<target name="test-repo-checked-write" depends="jar, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/CheckedWriteTest.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>
	
	<!-- This isnt run by the standard tests currently and it doesn't pass -->
	<target name="test-repo-simple-nameenumeration" depends="jar, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/SimpleNameEnumerationTest.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>
	
	<target name="test-repo-io" depends="jar, test-repo-structure, ccnd, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/RepoIOTest.class"/>
					<include name="org/ccnx/ccn/repo/RepoBulkImportTest.class" unless="${repo2}"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>
	
	<target name="test-repo-name-responder" depends="jar, ccnd, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/repo/RepoNameEnumeratorTest.class"/>
					<include name="org/ccnx/ccn/repo/MultiResponderNameEnumerationTest.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>

	<target name="test-endtoend" depends="jar, ccnd">
		<echo message="Running end-to-end test"/>
		<parallel failonany="true">
			<!-- timeout more than 2X average so sure timeout == failure -->
			<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perTest" timeout="200000" dir="${testout}" showoutput="${showoutput}">
				<classpath>
					<path refid="classpath-run"/>
				</classpath>
				<formatter type="xml" usefile="true"/>
				<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
				<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
				<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
	            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
        			<test todir="${testout}"  name="org.ccnx.ccn.endtoend.EndToEndTestSource"/>
			</junit>
			<junit printsummary="yes" haltonfailure="yes" fork="on" forkmode="perTest" timeout="200000" dir="${testout}" showoutput="${showoutput}">
				<classpath>
					<path refid="classpath-run"/>
				</classpath>
				<formatter type="xml" usefile="true"/>
				<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
				<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
				<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
				<test todir="${testout}"  name="org.ccnx.ccn.endtoend.EndToEndTestSink"/>
			</junit>
		</parallel>
	</target>

	<!-- Don't run this by default because it takes too much memory on some systems -->
	<target name="test-security-with-memory" depends="test-security-without-repo, test-security-with-repo" >
	</target>
	
	<target name="test-security" depends="test-security-with-repo">
	</target>
	
	<target name="test-security-without-repo" depends="jar, ccnd">
		<!-- Security tests that don't need a repo running -->
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" 
					showoutput="${showoutput}" maxmemory="1024m">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/security/crypto/*Test.class"/>
					<include name="org/ccnx/ccn/security/keys/*Test.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>

	<target name="test-security-with-repo" depends="jar, ccnd, repo">
		<!-- Security tests that need a repo running -->
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="yes" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/security/crypto/*TestRepo.class"/>
					<include name="org/ccnx/ccn/security/keys/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>

	<target name="test-access-control" depends="test-access-control-without-repo, test-access-control-with-repo">
	</target>
	
	<target name="test-access-control-without-repo" depends="jar, ccnd">
		<!-- Access Control tests that don't need a repo running -->
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="no" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/profiles/security/access/**/*Test.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>

	<target name="test-access-control-with-repo" depends="jar, ccnd, repo">
		<!-- Access Control tests that need a repo running -->
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perBatch" haltonfailure="no" dir="${testout}" showoutput="${showoutput}" maxmemory="1024m">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/profiles/security/access/**/*TestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>

	<!-- test versioning per Michael - these tests run very slowly on older, slower machines so it is purposely not
	     included in standard testing -->
	<target name="test-versioning" depends="jar, ccnd, repo">
		<mkdir dir="${testout}"/>
		<junit printsummary="yes" fork="on" forkmode="perTest" haltonfailure="no" dir="${testout}" showoutput="${showoutput}">
			<classpath>
				<path refid="classpath-run"/>
			</classpath>
			<formatter type="xml" usefile="true"/>
			<sysproperty key="ccn.agent.port" value="${TEST_PORT}"/>
			<sysproperty key="ccn.test.topdir" value="${TOP_DIR}"/>
			<sysproperty key="${LOGDIR_KEY}" value="${testoutlog}"/>
			<sysproperty key="org.ccnx.ccn.LogLevel.All" value="SEVERE"/>
			<sysproperty key="org.ccnx.ccn.LogLevel.FAC_ENCODING" value="INFO"/>
			<sysproperty key="${USE_KEY_CONFIG_KEY}" value="${USE_KEY_CONFIG_VAL}"/>
            <sysproperty key="${EXIT_ON_ERROR}" value="true"/>
			<batchtest todir="${testout}" >
				<fileset dir="${build}">
					<include name="org/ccnx/ccn/profiles/versioning/**/*Test.class"/>
					<include name="org/ccnx/ccn/profiles/versioning/**/*TestRepo.class"/>
					<include name="org/ccnx/ccn/profiles/versioning/**/XVersioningInterestTestRepo.class"/>
				</fileset>
			</batchtest>
		</junit>
		<!-- <delete dir="${REPO_ROOT}"/> -->
	</target>
	
    <target name="run-explorer" depends="jar"> 
		<!-- Not a unit test, this is to run the utility -->
		<java classname="org.ccnx.ccn.utils.explorer.ContainerGUI" fork="true">
                   <classpath>
                     <path refid="classpath-run"/>
                   </classpath>
        </java>
	</target>
	
	<target name="init">
		<echo message="Verifying Ant version is at least 1.8.0" />
		<fail message="Ant version is less than version 1.8.0, exiting.  Please upgrade your version of Ant.">
			<condition>
  				<not>
    				<antversion property="antversion" atleast="1.8.0"/>
  				</not>
			</condition>
		</fail>
	</target>
</project>