/************************************************************************
  Include settings/rules shared across all test Imakefile's
************************************************************************/
#include "Imakefile.common"

/* 
   If we're just doing "make all", the first thing we should do is
   build all the various lists we need (dealing with test classes,
   compiler subdirectories, etc), and do so in all the compiler  
   subdirectories.  This way, we can catch errors right away, and we
   get all that stuff out of the way early in the build.
*/
all_lists:: compiler_list
	@for X in `cat compiler_list` ; do \
	    make $$X/Makefile; \
	    cd $$X; make all_lists; cd ..; \
	done


/************************************************************************
   Shared settings/rules used by all tests in the top-level directory,
   and that deal with the testing build framework itself.
************************************************************************/

LD_DIR = -condor_ld_dir $(PRE_BUILT_RELEASE)/lib
LIB_DIR = -condor_lib $(PRE_BUILT_RELEASE)/lib
INCLUDE_FLAGS = -I$(PRE_BUILT_RELEASE)/include -I../condor_includes -I../h -I../condor_c++_util -I../condor_chirp
BUILD_FLAGS = $(TESTSUITE_FLAGS_GCC)
CC = gcc
CPlusPlus = g++
CFLAGS  = $(BUILD_FLAGS) $(INCLUDE_FLAGS) -g 
C_PLUS_FLAGS  = $(CFLAGS)

/* the perl infrastructure for running tests lives in another
   directory, so we have to add sylinks for those */
all_symlink_target(../condor_scripts/Condor.pm,Condor.pm)
all_symlink_target(../condor_scripts/CondorTest.pm,CondorTest.pm)
all_symlink_target(../condor_scripts/CondorPersonal.pm,CondorPersonal.pm)
all_symlink_target(../condor_scripts/CondorPubLogdirs.pm,CondorPubLogdirs.pm)
all_symlink_target(../condor_scripts/safe_append.pl,safe_append.pl)
all_symlink_target(../condor_scripts/batch_test.pl,batch_test.pl)

BUILD_DEP($(CC),x_return-n,c,x_waste_second.o)
BUILD($(CC),x_dumpcore,c)
BUILD($(CC),x_trapsig,c)
BUILD($(CC),x_tightloop,c)
BUILD($(CC),x_killppid,c)

/************************************************************************
   Rules for all the single-compiler (or no compiler) tests
************************************************************************/

/* Library tests */

/* Chirp */
#if !defined( IS_ALPHA_LINUX) && !defined( IS_HPUX10 )
/* 
   Gnats 546 Linux rh 7.2 on alph chip Needs MD5 perl module
   GNATS 548 perl md5 module missing on HPUX 10 machine(s)
*/
DESC(lib_chirpio_van,"Exercise the chirp I/O library using the C client library")
BUILD_DEP_LIB($(CC),lib_chirpio,c,,../release_dir/lib/libchirp_client.a)
DEPS(lib_chirpio_van,lib_chirpio.exe)
RUN(lib_chirpio_van)
TESTCLASS(lib_chirpio_van,lib)
TESTCLASS(lib_chirpio_van,quick)
TESTCLASS(lib_chirpio_van,full)

DESC(job_core_chirp_par,"Exercise the chirp I/O C library in Parallel Universe")
BUILD_DEP_LIB($(CC),job_core_chirp_par,c,,../release_dir/lib/libchirp_client.a)
DEPS(job_core_chirp_par,job_core_chirp_par.exe)
RUN(job_core_chirp_par)
TESTCLASS(job_core_chirp_par,lib)
TESTCLASS(job_core_chirp_par,quick)
TESTCLASS(job_core_chirp_par,full)
#endif 

/* User log and log reader used by dagman tests */

/* NOTE: since we are linking these with external libraries, we need
the BUILD_DEP_LIB() rule, which provides maximum flexibility.  but, in
this case, we only need to specify libs, not dependent .o files, so we
leave the 4th argument empty...
*/

BUILD_DEP_LIB($(CPlusPlus),x_read_joblog,C,,../release_dir/lib/libcondorapi.a)
BUILD_DEP_LIB($(CPlusPlus),x_write_joblog,C,,../release_dir/lib/libcondorapi.a)
BUILD_DEP_LIB($(CPlusPlus),x_write_joblog_events,C,,../release_dir/lib/libcondorapi.a)

BUILD_DEP_LIB($(CPlusPlus),lib_eventlog_base,C,,../release_dir/lib/libcondorapi.a)

/* BUG: We seem to consistently loose track of one pid on AIX
	so we will turn this test off until this gets fixed.....
	GNATS entry #558 for core condor software / proapi
*/

#if !defined( IS_HPUX10 )
/*
DESC(job_had_basic," Basic High Availability Daemon Test")
RUN(job_had_basic)
TESTCLASS(job_had_basic,core)
TESTCLASS(job_had_basic,quick)
TESTCLASS(job_had_basic,full)
TESTCLASS(job_had_basic,quicknolink)
*/
#endif

#if !defined(IS_PPC_AIX)
DESC(lib_procapi_pidtracking-snapshot,"Fast Termination Child Cleanup Test")
RUN(lib_procapi_pidtracking-snapshot)
TESTCLASS(lib_procapi_pidtracking-snapshot,core)
TESTCLASS(lib_procapi_pidtracking-snapshot,quick)
TESTCLASS(lib_procapi_pidtracking-snapshot,full)
TESTCLASS(lib_procapi_pidtracking-snapshot,quicknolink)
#endif

# Required ligo test needs to be enabled by configure
# but until then it is always on and will run correctly
# in the nightlies where the confidential tests are 
# correctly integrated with a trigger file in the config dir.
# bt 6/19/08

#if defined(IS_X86_64_LINUX_RHEL5)
DESC(job_ligo_x86-64-chkpttst,"Special LIGO test")
RUN(job_ligo_x86-64-chkpttst)
TESTCLASS(job_ligo_x86-64-chkpttst,core)
TESTCLASS(job_ligo_x86-64-chkpttst,quick)
TESTCLASS(job_ligo_x86-64-chkpttst,full)
TESTCLASS(job_ligo_x86-64-chkpttst,quicknolink)
TESTCLASS(job_ligo_x86-64-chkpttst,btdebug)
#endif

DESC(job_dagman_splice-A,"Simple Dagman Splice A")
RUN(job_dagman_splice-A)
TESTCLASS(job_dagman_splice-A,core)
TESTCLASS(job_dagman_splice-A,quick)
TESTCLASS(job_dagman_splice-A,full)
TESTCLASS(job_dagman_splice-A,quicknolink)
TESTCLASS(job_dagman_splice-A,btdebug)

DESC(job_dagman_splice-B,"Simple Dagman Splice B")
RUN(job_dagman_splice-B)
TESTCLASS(job_dagman_splice-B,core)
TESTCLASS(job_dagman_splice-B,quick)
TESTCLASS(job_dagman_splice-B,full)
TESTCLASS(job_dagman_splice-B,quicknolink)
TESTCLASS(job_dagman_splice-B,btdebug)

DESC(job_dagman_splice-C,"Simple Dagman Splice C")
RUN(job_dagman_splice-C)
TESTCLASS(job_dagman_splice-C,core)
TESTCLASS(job_dagman_splice-C,quick)
TESTCLASS(job_dagman_splice-C,full)
TESTCLASS(job_dagman_splice-C,quicknolink)
TESTCLASS(job_dagman_splice-C,btdebug)

DESC(job_dagman_splice-D,"Simple Dagman Splice D")
RUN(job_dagman_splice-D)
TESTCLASS(job_dagman_splice-D,core)
TESTCLASS(job_dagman_splice-D,quick)
TESTCLASS(job_dagman_splice-D,full)
TESTCLASS(job_dagman_splice-D,quicknolink)
TESTCLASS(job_dagman_splice-D,btdebug)

DESC(job_dagman_splice-E,"Simple Dagman Splice E")
RUN(job_dagman_splice-E)
TESTCLASS(job_dagman_splice-E,core)
TESTCLASS(job_dagman_splice-E,quick)
TESTCLASS(job_dagman_splice-E,full)
TESTCLASS(job_dagman_splice-E,quicknolink)
TESTCLASS(job_dagman_splice-E,btdebug)

DESC(job_dagman_splice-F,"Simple Dagman Splice F")
RUN(job_dagman_splice-F)
TESTCLASS(job_dagman_splice-F,core)
TESTCLASS(job_dagman_splice-F,quick)
TESTCLASS(job_dagman_splice-F,full)
TESTCLASS(job_dagman_splice-F,quicknolink)
TESTCLASS(job_dagman_splice-F,btdebug)

DESC(job_dagman_splice-G,"Simple Dagman Splice G")
RUN(job_dagman_splice-G)
TESTCLASS(job_dagman_splice-G,core)
TESTCLASS(job_dagman_splice-G,quick)
TESTCLASS(job_dagman_splice-G,full)
TESTCLASS(job_dagman_splice-G,quicknolink)
TESTCLASS(job_dagman_splice-G,btdebug)

DESC(job_dagman_splice-H,"Simple Dagman Splice H")
RUN(job_dagman_splice-H)
TESTCLASS(job_dagman_splice-H,core)
TESTCLASS(job_dagman_splice-H,quick)
TESTCLASS(job_dagman_splice-H,full)
TESTCLASS(job_dagman_splice-H,quicknolink)
TESTCLASS(job_dagman_splice-H,btdebug)

DESC(job_dagman_splice-I,"Simple Dagman Splice I")
RUN(job_dagman_splice-I)
TESTCLASS(job_dagman_splice-I,core)
TESTCLASS(job_dagman_splice-I,quick)
TESTCLASS(job_dagman_splice-I,full)
TESTCLASS(job_dagman_splice-I,quicknolink)
TESTCLASS(job_dagman_splice-I,btdebug)

/*	This test is commented out until we fix Condor.pm to allow multiple
	dag files to be submitted with condor_submit_dag in TestSubmitDagman
*/

/*
DESC(job_dagman_splice-J,"Simple Dagman Splice J")
RUN(job_dagman_splice-J)
TESTCLASS(job_dagman_splice-J,core)
TESTCLASS(job_dagman_splice-J,quick)
TESTCLASS(job_dagman_splice-J,full)
TESTCLASS(job_dagman_splice-J,quicknolink)
TESTCLASS(job_dagman_splice-J,btdebug)
*/

DESC(job_dagman_splice-K,"Simple Dagman Splice K")
RUN(job_dagman_splice-K)
TESTCLASS(job_dagman_splice-K,core)
TESTCLASS(job_dagman_splice-K,quick)
TESTCLASS(job_dagman_splice-K,full)
TESTCLASS(job_dagman_splice-K,quicknolink)
TESTCLASS(job_dagman_splice-K,btdebug)

DESC(job_dagman_splice-L,"Simple Dagman Splice L")
RUN(job_dagman_splice-L)
TESTCLASS(job_dagman_splice-L,core)
TESTCLASS(job_dagman_splice-L,quick)
TESTCLASS(job_dagman_splice-L,full)
TESTCLASS(job_dagman_splice-L,quicknolink)
TESTCLASS(job_dagman_splice-L,btdebug)

DESC(job_dagman_splice-M,"Simple Dagman Splice M")
RUN(job_dagman_splice-M)
TESTCLASS(job_dagman_splice-M,core)
TESTCLASS(job_dagman_splice-M,quick)
TESTCLASS(job_dagman_splice-M,full)
TESTCLASS(job_dagman_splice-M,quicknolink)
TESTCLASS(job_dagman_splice-M,btdebug)

DESC(job_dagman_splice-N,"Simple Dagman Splice N")
RUN(job_dagman_splice-N)
TESTCLASS(job_dagman_splice-N,core)
TESTCLASS(job_dagman_splice-N,quick)
TESTCLASS(job_dagman_splice-N,full)
TESTCLASS(job_dagman_splice-N,quicknolink)
TESTCLASS(job_dagman_splice-N,btdebug)

DESC(job_dagman_splice-O,"Simple Dagman Splice O")
RUN(job_dagman_splice-O)
TESTCLASS(job_dagman_splice-O,core)
TESTCLASS(job_dagman_splice-O,quick)
TESTCLASS(job_dagman_splice-O,full)
TESTCLASS(job_dagman_splice-O,quicknolink)
TESTCLASS(job_dagman_splice-O,btdebug)

/* vmuniverse tests in larg repository */

#if defined(HAVE_VMWARE)
DESC(job_vmu_basic,"VM Universe smoke test")
RUN(job_vmu_basic)
TESTCLASS(job_vmu_basic,core)
TESTCLASS(job_vmu_basic,quick)
TESTCLASS(job_vmu_basic,full)
TESTCLASS(job_vmu_basic,quicknolink)
TESTCLASS(job_vmu_basic,btdebug)
DESC(job_vmu_cdrom,"VM Universe CD-ROM test")
RUN(job_vmu_cdrom)
TESTCLASS(job_vmu_cdrom,core)
TESTCLASS(job_vmu_cdrom,quick)
TESTCLASS(job_vmu_cdrom,full)
TESTCLASS(job_vmu_cdrom,quicknolink)
TESTCLASS(job_vmu_cdrom,btdebug)
DESC(job_vmu_network,"VM Universe networking test")
RUN(job_vmu_network)
TESTCLASS(job_vmu_network,core)
TESTCLASS(job_vmu_network,quick)
TESTCLASS(job_vmu_network,full)
TESTCLASS(job_vmu_network,quicknolink)
TESTCLASS(job_vmu_network,btdebug)
DESC(job_vmu_ckpt,"VM Universe checkpoint test")
RUN(job_vmu_ckpt)
TESTCLASS(job_vmu_ckpt,core)
TESTCLASS(job_vmu_ckpt,quick)
TESTCLASS(job_vmu_ckpt,full)
TESTCLASS(job_vmu_ckpt,quicknolink)
TESTCLASS(job_vmu_ckpt,btdebug)
#endif 

/* We're not building OpenSSL on HPUX */
/* The threads in amazon_gahp are causing problems on AIX */
#if !defined( IS_HPUX11 ) && !defined( IS_AIX ) && !defined( IS_SOLARIS29 )
DESC(job_amazon_basic,"Amazon EC2 test")
RUN(job_amazon_basic)
TESTCLASS(job_amazon_basic,quick)
TESTCLASS(job_amazon_basic,full)
#endif 

DESC(job_flocking_to,"Simple flocking test")
RUN(job_flocking_to)
TESTCLASS(job_flocking_to,core)
TESTCLASS(job_flocking_to,quick)
TESTCLASS(job_flocking_to,full)
TESTCLASS(job_flocking_to,quicknolink)
TESTCLASS(job_flocking_to,btdebug)

DESC(fetch_work-basic,"work fetch smoke test")
RUN(fetch_work-basic)
TESTCLASS(fetch_work-basic,core)
TESTCLASS(fetch_work-basic,quick)
TESTCLASS(fetch_work-basic,quicknolink)
TESTCLASS(fetch_work-basic,btdebug)

/*
**
** Not in use till endurance testing done
DESC(lib_sysapi,"Run SysApi Tests")
RUN(lib_sysapi)
TESTCLASS(lib_sysapi,core)
TESTCLASS(lib_sysapi,quick)
TESTCLASS(lib_sysapi,full)
TESTCLASS(lib_sysapi,quicknolink)
TESTCLASS(lib_sysapi,btdebug)

DESC(lib_procapi,"Run ProcApi Tests")
RUN(lib_procapi)
TESTCLASS(lib_procapi,core)
TESTCLASS(lib_procapi,quick)
TESTCLASS(lib_procapi,full)
TESTCLASS(lib_procapi,quicknolink)
TESTCLASS(lib_procapi,btdebug)
*/

DESC(lib_unit_tests,"Run Unit Tests Tests")
RUN(lib_unit_tests)
TESTCLASS(lib_unit_tests,core)
TESTCLASS(lib_unit_tests,quick)
TESTCLASS(lib_unit_tests,full)
TESTCLASS(lib_unit_tests,quicknolink)
TESTCLASS(lib_unit_tests,btdebug)

DESC(lib_auth_config,"Run Authorization Config Tests")
RUN(lib_auth_config)
TESTCLASS(lib_auth_config,core)
TESTCLASS(lib_auth_config,quick)
TESTCLASS(lib_auth_config,full)
TESTCLASS(lib_auth_config,quicknolink)
TESTCLASS(lib_auth_config,btdebug)

DESC(lib_classads,"Run ClassAd Tests")
RUN(lib_classads)
TESTCLASS(lib_classads,core)
TESTCLASS(lib_classads,quick)
TESTCLASS(lib_classads,full)
TESTCLASS(lib_classads,quicknolink)
TESTCLASS(lib_classads,btdebug)

DESC(lib_auth_protocol-fs,"FS authentication test")
RUN(lib_auth_protocol-fs)
TESTCLASS(lib_auth_protocol-fs,core)
TESTCLASS(lib_auth_protocol-fs,quick)
TESTCLASS(lib_auth_protocol-fs,full)
TESTCLASS(lib_auth_protocol-fs,quicknolink)

DESC(lib_auth_protocol-ctb,"CTB authentication test")
RUN(lib_auth_protocol-ctb)
TESTCLASS(lib_auth_protocol-ctb,core)
TESTCLASS(lib_auth_protocol-ctb,quick)
TESTCLASS(lib_auth_protocol-ctb,full)
TESTCLASS(lib_auth_protocol-ctb,quicknolink)

/* GNATS 764 - SSL missing on Dux 5.1 and HPUX 11 machines */
#if !defined( IS_ALPHA_DUX5) && !defined( IS_HPUX11 )

DESC(lib_auth_protocol-ssl,"SSL authentication test")
RUN(lib_auth_protocol-ssl)
TESTCLASS(lib_auth_protocol-ssl,core)
TESTCLASS(lib_auth_protocol-ssl,quick)
TESTCLASS(lib_auth_protocol-ssl,full)
TESTCLASS(lib_auth_protocol-ssl,quicknolink)

/* Turn off till certs fixed 8/13/7
DESC(lib_auth_protocol-pw,"PW authentication test")
RUN(lib_auth_protocol-pw)
TESTCLASS(lib_auth_protocol-pw,core)
TESTCLASS(lib_auth_protocol-pw,quick)
TESTCLASS(lib_auth_protocol-pw,full)
TESTCLASS(lib_auth_protocol-pw,quicknolink)

DESC(lib_auth_protocol-gsi,"GSI authentication test")
RUN(lib_auth_protocol-gsi)
TESTCLASS(lib_auth_protocol-gsi,core)
TESTCLASS(lib_auth_protocol-gsi,quick)
TESTCLASS(lib_auth_protocol-gsi,full)
TESTCLASS(lib_auth_protocol-gsi,quicknolink)
*/

#endif

DESC(lib_auth_protocol-negot,"4 way negotiation test - frist 8")
RUN(lib_auth_protocol-negot)
TESTCLASS(lib_auth_protocol-negot,core)
TESTCLASS(lib_auth_protocol-negot,quick)
TESTCLASS(lib_auth_protocol-negot,full)
TESTCLASS(lib_auth_protocol-negot,quicknolink)

DESC(lib_auth_protocol-negot-prt2,"4 way negotiation test - last 8")
RUN(lib_auth_protocol-negot-prt2)
TESTCLASS(lib_auth_protocol-negot-prt2,core)
TESTCLASS(lib_auth_protocol-negot-prt2,quick)
TESTCLASS(lib_auth_protocol-negot-prt2,full)
TESTCLASS(lib_auth_protocol-negot-prt2,quicknolink)

DESC(lib_auth_protocol-negot-prt3,"4 way negotiation test - last 8")
RUN(lib_auth_protocol-negot-prt3)
TESTCLASS(lib_auth_protocol-negot-prt3,core)
TESTCLASS(lib_auth_protocol-negot-prt3,quick)
TESTCLASS(lib_auth_protocol-negot-prt3,full)
TESTCLASS(lib_auth_protocol-negot-prt3,quicknolink)

DESC(lib_auth_protocol-negot-prt4,"4 way negotiation test - last 8")
RUN(lib_auth_protocol-negot-prt4)
TESTCLASS(lib_auth_protocol-negot-prt4,core)
TESTCLASS(lib_auth_protocol-negot-prt4,quick)
TESTCLASS(lib_auth_protocol-negot-prt4,full)
TESTCLASS(lib_auth_protocol-negot-prt4,quicknolink)

/* Turned off on Free BSD port GNATS 766 */

DESC(cmd_status_shows-any,"Condor_status -any works as expected")
RUN(cmd_status_shows-any)
TESTCLASS(cmd_status_shows-any,core)
TESTCLASS(cmd_status_shows-any,quick)
TESTCLASS(cmd_status_shows-any,full)
TESTCLASS(cmd_status_shows-any,quicknolink)

DESC(cmd_status_shows-submitters,"Condor_status -submitters works as expected")
RUN(cmd_status_shows-submitters)
TESTCLASS(cmd_status_shows-submitters,core)
TESTCLASS(cmd_status_shows-submitters,quick)
TESTCLASS(cmd_status_shows-submitters,full)
TESTCLASS(cmd_status_shows-submitters,quicknolink)

DESC(cmd_status_shows-negotiator,"Condor_status -negotiator works as expected")
RUN(cmd_status_shows-negotiator)
TESTCLASS(cmd_status_shows-negotiator,core)
TESTCLASS(cmd_status_shows-negotiator,quick)
TESTCLASS(cmd_status_shows-negotiator,full)
TESTCLASS(cmd_status_shows-negotiator,quicknolink)

DESC(cmd_status_shows-state,"Condor_status -state works as expected")
RUN(cmd_status_shows-state)
TESTCLASS(cmd_status_shows-state,core)
TESTCLASS(cmd_status_shows-state,quick)
TESTCLASS(cmd_status_shows-state,full)
TESTCLASS(cmd_status_shows-state,quicknolink)

DESC(cmd_status_shows-format,"Condor_status -format works as expected")
RUN(cmd_status_shows-format)
TESTCLASS(cmd_status_shows-format,core)
TESTCLASS(cmd_status_shows-format,quick)
TESTCLASS(cmd_status_shows-format,full)
TESTCLASS(cmd_status_shows-format,quicknolink)

DESC(cmd_status_shows-constraint,"Condor_status -constraint works as expected")
RUN(cmd_status_shows-constraint)
TESTCLASS(cmd_status_shows-constraint,core)
TESTCLASS(cmd_status_shows-constraint,quick)
TESTCLASS(cmd_status_shows-constraint,full)
TESTCLASS(cmd_status_shows-constraint,quicknolink)

DESC(cmd_status_shows-avail,"Condor_status -avail works as expected")
RUN(cmd_status_shows-avail)
TESTCLASS(cmd_status_shows-avail,core)
TESTCLASS(cmd_status_shows-avail,quick)
TESTCLASS(cmd_status_shows-avail,full)
TESTCLASS(cmd_status_shows-avail,quicknolink)

DESC(cmd_status_shows-claim,"Condor_status -claim works as expected")
RUN(cmd_status_shows-claim)
TESTCLASS(cmd_status_shows-claim,core)
TESTCLASS(cmd_status_shows-claim,quick)
TESTCLASS(cmd_status_shows-claim,full)
TESTCLASS(cmd_status_shows-claim,quicknolink)

DESC(cmd_status_shows-help,"Condor_status -help works as expected")
RUN(cmd_status_shows-help)
TESTCLASS(cmd_status_shows-help,core)
TESTCLASS(cmd_status_shows-help,quick)
TESTCLASS(cmd_status_shows-help,full)
TESTCLASS(cmd_status_shows-help,quicknolink)

DESC(cmd_status_shows-master,"Condor_status -master works as expected")
RUN(cmd_status_shows-master)
TESTCLASS(cmd_status_shows-master,core)
TESTCLASS(cmd_status_shows-master,quick)
TESTCLASS(cmd_status_shows-master,full)
TESTCLASS(cmd_status_shows-master,quicknolink)

DESC(cmd_status_shows-schedd,"Condor_status -schedd works as expected")
RUN(cmd_status_shows-schedd)
TESTCLASS(cmd_status_shows-schedd,core)
TESTCLASS(cmd_status_shows-schedd,quick)
TESTCLASS(cmd_status_shows-schedd,full)
TESTCLASS(cmd_status_shows-schedd,quicknolink)

DESC(cmd_status_shows-startd,"Condor_status -startd works as expected")
RUN(cmd_status_shows-startd)
TESTCLASS(cmd_status_shows-startd,core)
TESTCLASS(cmd_status_shows-startd,quick)
TESTCLASS(cmd_status_shows-startd,full)
TESTCLASS(cmd_status_shows-startd,quicknolink)

DESC(cmd_q_shows-hold,"Condor_q shows hold")
RUN(cmd_q_shows-hold)
TESTCLASS(cmd_q_shows-hold,core)
TESTCLASS(cmd_q_shows-hold,quick)
TESTCLASS(cmd_q_shows-hold,full)
TESTCLASS(cmd_q_shows-hold,quicknolink)

DESC(cmd_q_shows-run,"Condor_q shows run")
RUN(cmd_q_shows-run)
TESTCLASS(cmd_q_shows-run,core)
TESTCLASS(cmd_q_shows-run,quick)
TESTCLASS(cmd_q_shows-run,full)
TESTCLASS(cmd_q_shows-run,quicknolink)

DESC(cmd_q_shows-global,"Condor_q shows global")
RUN(cmd_q_shows-global)
TESTCLASS(cmd_q_shows-global,core)
TESTCLASS(cmd_q_shows-global,quick)
TESTCLASS(cmd_q_shows-global,full)
TESTCLASS(cmd_q_shows-global,quicknolink)

DESC(cmd_q_shows-name,"Condor_q shows name")
RUN(cmd_q_shows-name)
TESTCLASS(cmd_q_shows-name,core)
TESTCLASS(cmd_q_shows-name,quick)
TESTCLASS(cmd_q_shows-name,full)
TESTCLASS(cmd_q_shows-name,quicknolink)

DESC(cmd_q_shows-pool,"Condor_q shows pool")
RUN(cmd_q_shows-pool)
TESTCLASS(cmd_q_shows-pool,core)
TESTCLASS(cmd_q_shows-pool,quick)
TESTCLASS(cmd_q_shows-pool,full)
TESTCLASS(cmd_q_shows-pool,quicknolink)

DESC(cmd_q_shows-sub,"Condor_q shows sub")
RUN(cmd_q_shows-sub)
TESTCLASS(cmd_q_shows-sub,core)
TESTCLASS(cmd_q_shows-sub,quick)
TESTCLASS(cmd_q_shows-sub,full)
TESTCLASS(cmd_q_shows-sub,quicknolink)

DESC(cmd_q_shows-analyze,"Condor_q shows analyze")
RUN(cmd_q_shows-analyze)
TESTCLASS(cmd_q_shows-analyze,core)
TESTCLASS(cmd_q_shows-analyze,quick)
TESTCLASS(cmd_q_shows-analyze,full)
TESTCLASS(cmd_q_shows-analyze,quicknolink)

DESC(cmd_q_shows-better-analyze,"Condor_q shows better-analyze")
RUN(cmd_q_shows-better-analyze)
TESTCLASS(cmd_q_shows-better-analyze,core)
TESTCLASS(cmd_q_shows-better-analyze,quick)
TESTCLASS(cmd_q_shows-better-analyze,full)
TESTCLASS(cmd_q_shows-better-analyze,quicknolink)

DESC(cmd_q_shows-xml,"Condor_q shows xml")
RUN(cmd_q_shows-xml)
TESTCLASS(cmd_q_shows-xml,core)
TESTCLASS(cmd_q_shows-xml,quick)
TESTCLASS(cmd_q_shows-xml,full)
TESTCLASS(cmd_q_shows-xml,quicknolink)

DESC(cmd_q_shows-cputime,"Condor_q shows cputime")
RUN(cmd_q_shows-cputime)
TESTCLASS(cmd_q_shows-cputime,core)
TESTCLASS(cmd_q_shows-cputime,quick)
TESTCLASS(cmd_q_shows-cputime,full)
TESTCLASS(cmd_q_shows-cputime,quicknolink)

DESC(cmd_q_shows-format,"Condor_q shows format")
RUN(cmd_q_shows-format)
TESTCLASS(cmd_q_shows-format,core)
TESTCLASS(cmd_q_shows-format,quick)
TESTCLASS(cmd_q_shows-format,full)
TESTCLASS(cmd_q_shows-format,quicknolink)

DESC(lib_userlog,"Exercise the userlog interface write and read all events");
RUN(lib_userlog)
DEPS(lib_userlog,x_read_joblog.exe)
DEPS(lib_userlog,x_write_joblog.exe)
TESTCLASS(lib_userlog,lib)
TESTCLASS(lib_userlog,quick)
TESTCLASS(lib_userlog,full)

DESC(lib_eventlog,"Basic Event Log Test")
RUN(lib_eventlog)
DEPS(lib_eventlog,x_read_joblog.exe)
TESTCLASS(lib_eventlog,core)
TESTCLASS(lib_eventlog,quick)
TESTCLASS(lib_eventlog,full)

DESC(lib_eventlog-xml,"Basic XML Event Log Test")
RUN(lib_eventlog-xml)
DEPS(lib_eventlog-xml,x_read_joblog.exe)
TESTCLASS(lib_eventlog-xml,core)
TESTCLASS(lib_eventlog-xml,quick)
TESTCLASS(lib_eventlog-xml,full)

/* Test to verify that re-initialization of the eventlog reader does not
   cause seg faults */
DESC(lib_eventlog_base,"Test re-initialization of eventlog reader")
RUN(lib_eventlog_base)
DEPS(lib_eventlog_base,lib_eventlog_base.exe)
DEPS(lib_eventlog_base,lib_eventlog_base.exe)
TESTCLASS(lib_eventlog_base,lib)
TESTCLASS(lib_eventlog_base,quick)
TESTCLASS(lib_eventlog_base,full)

#if defined(IS_IA64_LINUX_RHEL3) || defined(IS_CONDOR_PPC_LINUX_SLES9) || defined(IS_PPC_OSX_10_4) || defined(IS_CONDOR_PPC_LINUX_YD50) || defined(IS_X86_64_LINUX_RHEL5)  || defined(IS_X86_64_LINUX_RHEL3) || defined(IS_I386_OSX_10_4) || defined(IS_I386_LINUX_RHEL5) || defined(IS_I386_LINUX_RHEL51)
DESC(lib_eventlog_build,"Test building of eventlog program")
RUN(lib_eventlog_build)
TESTCLASS(lib_eventlog_build,lib)
TESTCLASS(lib_eventlog_build,quick)
TESTCLASS(lib_eventlog_build,full)
#endif

/* EventLog Rotation tests */
DESC(lib_eventlog_rotation-defaults,"Event Log Rotation: Default settings")
RUN(lib_eventlog_rotation-defaults)
TESTCLASS(lib_eventlog_rotation-defaults,core)
TESTCLASS(lib_eventlog_rotation-defaults,quick)
TESTCLASS(lib_eventlog_rotation-defaults,full)

DESC(lib_eventlog_rotation-no_rotations_1,"Event Log Rotation: no rotations/1")
RUN(lib_eventlog_rotation-no_rotations_1)
TESTCLASS(lib_eventlog_rotation-no_rotations_1,core)
TESTCLASS(lib_eventlog_rotation-no_rotations_1,quick)
TESTCLASS(lib_eventlog_rotation-no_rotations_1,full)

DESC(lib_eventlog_rotation-no_rotations_2,"Event Log Rotation: no rotations/2")
RUN(lib_eventlog_rotation-no_rotations_2)
TESTCLASS(lib_eventlog_rotation-no_rotations_2,core)
TESTCLASS(lib_eventlog_rotation-no_rotations_2,quick)
TESTCLASS(lib_eventlog_rotation-no_rotations_2,full)

DESC(lib_eventlog_rotation-no_rotations_3,"Event Log Rotation: no rotations/3")
RUN(lib_eventlog_rotation-no_rotations_3)
TESTCLASS(lib_eventlog_rotation-no_rotations_3,core)
TESTCLASS(lib_eventlog_rotation-no_rotations_3,quick)
TESTCLASS(lib_eventlog_rotation-no_rotations_3,full)

DESC(lib_eventlog_rotation-w_old_rotations,"Event Log Rotation: old rotations")
RUN(lib_eventlog_rotation-w_old_rotations)
TESTCLASS(lib_eventlog_rotation-w_old_rotations,core)
TESTCLASS(lib_eventlog_rotation-w_old_rotations,quick)
TESTCLASS(lib_eventlog_rotation-w_old_rotations,full)

DESC(lib_eventlog_rotation-w_old_rotations_2_loops,"Event Log Rotation: old rotations / 2 loops")
RUN(lib_eventlog_rotation-w_old_rotations_2_loops)
TESTCLASS(lib_eventlog_rotation-w_old_rotations_2_loops,core)
TESTCLASS(lib_eventlog_rotation-w_old_rotations_2_loops,quick)
TESTCLASS(lib_eventlog_rotation-w_old_rotations_2_loops,full)

DESC(lib_eventlog_rotation-w_2_rotations,"Event Log Rotation: 2 rotations")
RUN(lib_eventlog_rotation-w_2_rotations)
TESTCLASS(lib_eventlog_rotation-w_2_rotations,core)
TESTCLASS(lib_eventlog_rotation-w_2_rotations,quick)
TESTCLASS(lib_eventlog_rotation-w_2_rotations,full)

DESC(lib_eventlog_rotation-w_2_rotations_2_loops,"Event Log Rotation: 2 rotations / 2 loops")
RUN(lib_eventlog_rotation-w_2_rotations_2_loops)
TESTCLASS(lib_eventlog_rotation-w_2_rotations_2_loops,core)
TESTCLASS(lib_eventlog_rotation-w_2_rotations_2_loops,quick)
TESTCLASS(lib_eventlog_rotation-w_2_rotations_2_loops,full)

DESC(lib_eventlog_rotation-w_5_rotations,"Event Log Rotation: 5 rotations")
RUN(lib_eventlog_rotation-w_5_rotations)
TESTCLASS(lib_eventlog_rotation-w_5_rotations,core)
TESTCLASS(lib_eventlog_rotation-w_5_rotations,quick)
TESTCLASS(lib_eventlog_rotation-w_5_rotations,full)

DESC(lib_eventlog_rotation-w_20_rotations,"Event Log Rotation: 20 rotations")
RUN(lib_eventlog_rotation-w_20_rotations)
TESTCLASS(lib_eventlog_rotation-w_20_rotations,core)
TESTCLASS(lib_eventlog_rotation-w_20_rotations,quick)
TESTCLASS(lib_eventlog_rotation-w_20_rotations,full)

DESC(lib_eventlog_rotation-w_20_rotations_2_loops,"Event Log Rotation: 20 rotations / 2 loops")
RUN(lib_eventlog_rotation-w_20_rotations_2_loops)
TESTCLASS(lib_eventlog_rotation-w_20_rotations_2_loops,core)
TESTCLASS(lib_eventlog_rotation-w_20_rotations_2_loops,quick)
TESTCLASS(lib_eventlog_rotation-w_20_rotations_2_loops,full)

DESC(lib_eventlog_rotation-w_20_rotations_20_loops,"Event Log Rotation: 20 rotations / 20 loops")
RUN(lib_eventlog_rotation-w_20_rotations_20_loops)
TESTCLASS(lib_eventlog_rotation-w_20_rotations_20_loops,core)
TESTCLASS(lib_eventlog_rotation-w_20_rotations_20_loops,quick)
TESTCLASS(lib_eventlog_rotation-w_20_rotations_20_loops,full)

DESC(lib_eventlog_rotation-reader_simple,"Event Log Rotation: reader")
RUN(lib_eventlog_rotation-reader_simple)
TESTCLASS(lib_eventlog_rotation-reader_simple,core)
TESTCLASS(lib_eventlog_rotation-reader_simple,quick)
TESTCLASS(lib_eventlog_rotation-reader_simple,full)

DESC(lib_eventlog_rotation-reader_old_rotations,"Event Log Rotation: reader, old rotations")
RUN(lib_eventlog_rotation-reader_old_rotations)
TESTCLASS(lib_eventlog_rotation-reader_old_rotations,core)
TESTCLASS(lib_eventlog_rotation-reader_old_rotations,quick)
TESTCLASS(lib_eventlog_rotation-reader_old_rotations,full)

DESC(lib_eventlog_rotation-reader_2_rotations,"Event Log Rotation: reader, 2 rotations")
RUN(lib_eventlog_rotation-reader_2_rotations)
TESTCLASS(lib_eventlog_rotation-reader_2_rotations,core)
TESTCLASS(lib_eventlog_rotation-reader_2_rotations,quick)
TESTCLASS(lib_eventlog_rotation-reader_2_rotations,full)

DESC(lib_eventlog_rotation-reader_2_rotations_2_loops,"Event Log Rotation: reader, 2 rotations / 2 loops")
RUN(lib_eventlog_rotation-reader_2_rotations_2_loops)
TESTCLASS(lib_eventlog_rotation-reader_2_rotations_2_loops,core)
TESTCLASS(lib_eventlog_rotation-reader_2_rotations_2_loops,quick)
TESTCLASS(lib_eventlog_rotation-reader_2_rotations_2_loops,full)

DESC(lib_eventlog_rotation-reader_20_rotations,"Event Log Rotation: reader, 20 rotations")
RUN(lib_eventlog_rotation-reader_20_rotations)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations,core)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations,quick)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations,full)

DESC(lib_eventlog_rotation-reader_20_rotations_2_loops,"Event Log Rotation: reader, 20 rotations / 2 loops")
RUN(lib_eventlog_rotation-reader_20_rotations_2_loops)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations_2_loops,core)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations_2_loops,quick)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations_2_loops,full)

DESC(lib_eventlog_rotation-reader_20_rotations_20_loops,"Event Log Rotation: reader, 20 rotations / 20 loops")
RUN(lib_eventlog_rotation-reader_20_rotations_20_loops)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations_20_loops,core)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations_20_loops,quick)
TESTCLASS(lib_eventlog_rotation-reader_20_rotations_20_loops,full)

DESC(lib_eventlog_rotation-reader_missed_1,"Event Log Rotation: reader, missed events #1")
RUN(lib_eventlog_rotation-reader_missed_1)
TESTCLASS(lib_eventlog_rotation-reader_missed_1,core)
TESTCLASS(lib_eventlog_rotation-reader_missed_1,quick)
TESTCLASS(lib_eventlog_rotation-reader_missed_1,full)

DESC(lib_eventlog_rotation-reader_missed_2,"Event Log Rotation: reader, missed events #2")
RUN(lib_eventlog_rotation-reader_missed_2)
TESTCLASS(lib_eventlog_rotation-reader_missed_2,core)
TESTCLASS(lib_eventlog_rotation-reader_missed_2,quick)
TESTCLASS(lib_eventlog_rotation-reader_missed_2,full)


/* Lease Manager tests */
DESC(lib_lease_manager-simple,"Lease manager: Simple test")
RUN(lib_lease_manager-simple)
TESTCLASS(lib_lease_manager-simple,core)
TESTCLASS(lib_lease_manager-simple,quick)
TESTCLASS(lib_lease_manager-simple,full)

DESC(lib_lease_manager-get_rel_1,"Lease manager: get/relesae test #1")
RUN(lib_lease_manager-get_rel_1)
TESTCLASS(lib_lease_manager-get_rel_1,core)
TESTCLASS(lib_lease_manager-get_rel_1,quick)
TESTCLASS(lib_lease_manager-get_rel_1,full)

DESC(lib_lease_manager-get_rel_2,"Lease manager: get/relesae test #2")
RUN(lib_lease_manager-get_rel_2)
TESTCLASS(lib_lease_manager-get_rel_2,core)
TESTCLASS(lib_lease_manager-get_rel_2,quick)
TESTCLASS(lib_lease_manager-get_rel_2,full)

DESC(lib_lease_manager-get_rel_3,"Lease manager: get/relesae test #3")
RUN(lib_lease_manager-get_rel_3)
TESTCLASS(lib_lease_manager-get_rel_3,core)
TESTCLASS(lib_lease_manager-get_rel_3,quick)
TESTCLASS(lib_lease_manager-get_rel_3,full)

DESC(lib_lease_manager-get_rel_4,"Lease manager: get/relesae test #4")
RUN(lib_lease_manager-get_rel_4)
TESTCLASS(lib_lease_manager-get_rel_4,core)
TESTCLASS(lib_lease_manager-get_rel_4,quick)
TESTCLASS(lib_lease_manager-get_rel_4,full)

DESC(lib_lease_manager-get_rel_5,"Lease manager: get/relesae test #5")
RUN(lib_lease_manager-get_rel_5)
TESTCLASS(lib_lease_manager-get_rel_5,core)
TESTCLASS(lib_lease_manager-get_rel_5,quick)
TESTCLASS(lib_lease_manager-get_rel_5,full)

#if defined(IS_IA64_LINUX_RHEL3) || defined(IS_CONDOR_PPC_LINUX_SLES9) || defined(IS_PPC_OSX_10_4) || defined(IS_CONDOR_PPC_LINUX_YD50) || defined(IS_X86_64_LINUX_RHEL5)  || defined(IS_X86_64_LINUX_RHEL3) || defined(IS_I386_CONDOR_FREEBSD) || defined(IS_I386_OSX_10_4) || defined(IS_I386_LINUX_RHEL5) || defined(IS_I386_LINUX_RHEL51)
DESC(job_quill_basic,"Basic Quill Test")
RUN(job_quill_basic)
TESTCLASS(job_quill_basic,core)
TESTCLASS(job_quill_basic,quick)
TESTCLASS(job_quill_basic,full)
TESTCLASS(job_quill_basic,quicknolink)
TESTCLASS(job_quill_basic,btdebug)
#endif

DESC(job_core_basic_par,"Basic Parallel Universe")
RUN(job_core_basic_par)
TESTCLASS(job_core_basic_par,core)
TESTCLASS(job_core_basic_par,quick)
TESTCLASS(job_core_basic_par,full)
TESTCLASS(job_core_basic_par,quicknolink)

/*
****************** Tests being readied for prime time **********************

DESC(job_core_basic-security_par,"Basic Parallel Universe w/security on")
RUN(job_core_basic-security_par)
TESTCLASS(job_core_basic-security_par,core)
TESTCLASS(job_core_basic-security_par,quick)
TESTCLASS(job_core_basic-security_par,full)
TESTCLASS(job_core_basic-security_par,quicknolink)

DESC(job_stork_file-file,"Basic stork Test")
RUN(job_stork_file-file)
TESTCLASS(job_stork_file-file,core)
TESTCLASS(job_stork_file-file,quick)
TESTCLASS(job_stork_file-file,full)
TESTCLASS(job_stork_file-file,quicknolink)

DESC(job_dagman_stork-file-file,"Basic stork dag Test")
RUN(job_dagman_stork-file-file)
TESTCLASS(job_dagman_stork-file-file,core)
TESTCLASS(job_dagman_stork-file-file,quick)
TESTCLASS(job_dagman_stork-file-file,full)
TESTCLASS(job_dagman_stork-file-file,quicknolink)

DESC(job_dagman_stork-remove,"Basic stork dag w/remove Test")
RUN(job_dagman_stork-remove)
TESTCLASS(job_dagman_stork-remove,core)
TESTCLASS(job_dagman_stork-remove,quick)
TESTCLASS(job_dagman_stork-remove,full)
TESTCLASS(job_dagman_stork-remove,quicknolink)

****************** Tests being readied for prime time **********************
*/

#if !defined( IS_DARWIN ) && !defined(IS_DUX5) && !defined(IS_HPUX10) && !defined(IS_PPC_AIX) && !defined(IS_SOLARIS28) && !defined(IS_SOLARIS29) && !defined(IS_IRIX) && !defined(IS_HPUX11) && !defined(IS_CONDOR_FREEBSD)
/* 
   Gnats 545 this procapi test of pid tracking not working MacOsX
   Gnats 547 this procapi test of pid tracking not working IS_ALPHA_OSF1_V5 IS_HPUX10 IS_PPC_AIX SOLARIS28 SOLARIS29 
*/
DESC(lib_procapi_pidtracking-byenv,"Slow Termination Child Cleanup Test")
RUN(lib_procapi_pidtracking-byenv)
TESTCLASS(lib_procapi_pidtracking-byenv,core)
TESTCLASS(lib_procapi_pidtracking-byenv,quick)
TESTCLASS(lib_procapi_pidtracking-byenv,full)
TESTCLASS(lib_procapi_pidtracking-byenv,quicknolink)
#endif

#if 0
/*
   this test is just a big race condition, and doesn't actually test
   what it claims it's testing.  futhermore, it has nothing to do with
   vanilla universe, so at the very least, it should be renamed.  for
   now, i'm disabling it, since it's consistently been one of the only
   tests that's failing, and it's because of the test, not condor.
   we should either remove it completely, or re-implement it from
   scratch with a better methodology and a decent name.
*/  
DESC(job_schedd_job-tracking_van,"Scheduler: test for schedd loosing track of jobs")
RUN(job_schedd_job-tracking_van)
TESTCLASS(job_schedd_job-tracking_van,core)
TESTCLASS(job_schedd_job-tracking_van,quick)
TESTCLASS(job_schedd_job-tracking_van,full)
TESTCLASS(job_schedd_job-tracking_van,quicknolink)
#endif /* 0 -- test disabled */

DESC(job_core_err_java,"Java Universe: basic error test")
RUN(job_core_err_java)
TESTCLASS(job_core_err_java,core)
TESTCLASS(job_core_err_java,quick)
TESTCLASS(job_core_err_java,full)
TESTCLASS(job_core_err_java,quicknolink)

DESC(job_core_output_java,"Java Universe: basic output test")
RUN(job_core_output_java)
TESTCLASS(job_core_output_java,core)
TESTCLASS(job_core_output_java,quick)
TESTCLASS(job_core_output_java,full)
TESTCLASS(job_core_output_java,quicknolink)

DESC(job_core_hold_java,"Java Universe: basic output test")
RUN(job_core_hold_java)
TESTCLASS(job_core_hold_java,core)
TESTCLASS(job_core_hold_java,quick)
TESTCLASS(job_core_hold_java,full)
TESTCLASS(job_core_hold_java,quicknolink)

DESC(job_core_initialdir_java,"Java Universe: basic output test")
RUN(job_core_initialdir_java)
TESTCLASS(job_core_initialdir_java,core)
TESTCLASS(job_core_initialdir_java,quick)
TESTCLASS(job_core_initialdir_java,full)
TESTCLASS(job_core_initialdir_java,quicknolink)

DESC(job_core_input_java,"Java Universe: basic output test")
RUN(job_core_input_java)
TESTCLASS(job_core_input_java,core)
TESTCLASS(job_core_input_java,quick)
TESTCLASS(job_core_input_java,full)
TESTCLASS(job_core_input_java,quicknolink)

/*
** This test is simply submit and getting things in the job ads
** and fails unpredictably and duplicates the other "plus" tests.
***************************************************************
DESC(job_core_plus_java,"Java Universe: basic output test")
RUN(job_core_plus_java)
TESTCLASS(job_core_plus_java,core)
TESTCLASS(job_core_plus_java,quick)
TESTCLASS(job_core_plus_java,full)
TESTCLASS(job_core_plus_java,quicknolink)
***************************************************************
*/

/*
Gnats bugs 723 and 724
Gnats bug 790 for john memory failings
*/
#if !defined( IS_CONDOR_PPC_LINUX_SLES9 ) && !defined(IS_IA64_LINUX_SLES81) && !defined( IS_CONDOR_PPC_LINUX_YD30 ) && !defined( IS_I386_LINUX_RHEL3 ) && !defined( IS_ALPHA_DUX5 ) && !defined( IS_CONDOR_PPC_LINUX_YD50 )
DESC(soap_job_tests,"Soap: currently 10 different interface tests")
RUN(soap_job_tests)
TESTCLASS(soap_job_tests,core)
TESTCLASS(soap_job_tests,quick)
TESTCLASS(soap_job_tests,full)
TESTCLASS(soap_job_tests,quicknolink)
#endif


DESC(job_filexfer_streamout_van,"Vanilla: test for streaming of output when both stream_output is true and false")
RUN(job_filexfer_streamout_van)
TESTCLASS(job_filexfer_streamout_van,core)
TESTCLASS(job_filexfer_streamout_van,quick)
TESTCLASS(job_filexfer_streamout_van,full)
TESTCLASS(job_filexfer_streamout_van,quicknolink)

DESC(job_filexfer_streamerr_van,"Vanilla: test for streaming of error when both stream_error is true and false")
RUN(job_filexfer_streamerr_van)
TESTCLASS(job_filexfer_streamerr_van,core)
TESTCLASS(job_filexfer_streamerr_van,quick)
TESTCLASS(job_filexfer_streamerr_van,full)
TESTCLASS(job_filexfer_streamerr_van,quicknolink)

#if !defined( IS_ALPHA_LINUX) && !defined(IS_HPUX10) && !defined(IS_HPUX11) && !defined(IS_IA64_LINUX_SLES81) && !defined(IS_IA64_LINUX_RHEL3) 
/* 
   NOTE: this is an unfortunate way to do this selection.  we should
   have reliable HAVE_GLOBUS, HAVE_CONDOR_C, and HAVE_CONDOR_G macros
   defined via autoconf so we can just check "#if HAVE_CONDOR_C"
   for these tests, instead of doing it via platforms like this.

   Gnats 544 Linux rh 7.2 on alph chip is broken
   Gnats 561 HPUX 10 does not allow submits for lack of globus support.
   gthain says condor-c is not support to work on HPUX 11, either
*/
DESC(job_condorc_ab_van,"Condor-C AB test")
RUN(job_condorc_ab_van)
TESTCLASS(job_condorc_ab_van,condorc)
TESTCLASS(job_condorc_ab_van,quick)
TESTCLASS(job_condorc_ab_van,full)
TESTCLASS(job_condorc_ab_van,quicknolink)

DESC(job_condorc_abc_van,"Condor-C ABC test")
RUN(job_condorc_abc_van)
TESTCLASS(job_condorc_abc_van,condorc)
TESTCLASS(job_condorc_abc_van,quick)
TESTCLASS(job_condorc_abc_van,full)
TESTCLASS(job_condorc_abc_van,quicknolink)
#endif

/* Gnats bug 895 for aix returning too much user cpu usage and
**
** TURNED OFF TILL DEBUG of why time falls so short in NMI
**
**
for the three mac platforms returning no cpu usage - Gnats bug 896 
#if !defined(IS_PPC_AIX5) && !defined(IS_PPC_OSX_10_3) && !defined(IS_PPC_OSX_10_4) && !defined(IS_I386_OSX_10_4)
DESC(lib_procapi_cputracking-snapshot,"Scheduler: Verify the specified input file is used")
RUN(lib_procapi_cputracking-snapshot)
DEPS(lib_procapi_cputracking-snapshot,x_tightloop.exe)
TESTCLASS(lib_procapi_cputracking-snapshot,core)
TESTCLASS(lib_procapi_cputracking-snapshot,quick)
TESTCLASS(lib_procapi_cputracking-snapshot,full)
TESTCLASS(lib_procapi_cputracking-snapshot,quicknolink)
TESTCLASS(lib_procapi_cputracking-snapshot,btdebug)
#endif
**
*/

DESC(job_core_killsignal_sched,"Scheduler: Verify the specified input file is used")
RUN(job_core_killsignal_sched)
DEPS(job_core_killsignal_sched,x_trapsig.exe)
TESTCLASS(job_core_killsignal_sched,core)
TESTCLASS(job_core_killsignal_sched,quick)
TESTCLASS(job_core_killsignal_sched,full)
TESTCLASS(job_core_killsignal_sched,quicknolink)

/*
** The test in hanging in 6.7.x turn off for now.
DESC(job_core_holdkillsig_sched,"Scheduler: Verify ability to control signal for holds and kills")
RUN(job_core_holdkillsig_sched)
DEPS(job_core_holdkillsig_sched,x_trapsig.exe)
TESTCLASS(job_core_holdkillsig_sched,core)
TESTCLASS(job_core_holdkillsig_sched,quick)
TESTCLASS(job_core_holdkillsig_sched,full)
TESTCLASS(job_core_holdkillsig_sched,quicknolink)
*/

DESC(job_core_rmkillsig_sched,"Scheduler: Verify the  remove_kill_sig")
RUN(job_core_rmkillsig_sched)
DEPS(job_core_rmkillsig_sched,x_trapsig.exe)
TESTCLASS(job_core_rmkillsig_sched,core)
TESTCLASS(job_core_rmkillsig_sched,quick)
TESTCLASS(job_core_rmkillsig_sched,full)
TESTCLASS(job_core_rmkillsig_sched,quicknolink)

DESC(job_core_macros-dollardollar_van,"Vanilla: Did dollar dollar macros work?")
RUN(job_core_macros-dollardollar_van)
TESTCLASS(job_core_macros-dollardollar_van,core)
TESTCLASS(job_core_macros-dollardollar_van,quick)
TESTCLASS(job_core_macros-dollardollar_van,full)
TESTCLASS(job_core_macros-dollardollar_van,quicknolink)

/*
**
**DESC(job_core_killsignal_van,"Vanilla: Verify the specified input file is used")
**RUN(job_core_killsignal_van)
**DEPS(job_core_killsignal_van,x_trapsig.exe)
**TESTCLASS(job_core_killsignal_van,core)
**TESTCLASS(job_core_killsignal_van,quick)
**
**DESC(job_core_corefiles_van,"Vanillla limit of core file size - FAILS!")
**RUN(job_core_corefiles_van)
**TESTCLASS(job_core_corefiles_van,core)
**TESTCLASS(job_core_corefiles_van,quick)
**
**DESC(job_core_corefiles_sched,"Scheduler limit of core file size - FAILS!")
**RUN(job_core_corefiles_sched)
**TESTCLASS(job_core_corefiles_sched,core)
**TESTCLASS(job_core_corefiles_sched,quick)
**
*/

/**
 * Local Universe Policy Expression Tests
 **/

DESC(job_core_onexithold_local,"Local: Verify true and false triggers of on_exit_hold")
RUN(job_core_onexithold_local)
TESTCLASS(job_core_onexithold_local,core)
TESTCLASS(job_core_onexithold_local,quick)
TESTCLASS(job_core_onexithold_local,full)
TESTCLASS(job_core_onexithold_local,quicknolink)
TESTCLASS(job_core_onexithold_local,local)

DESC(job_core_onexitrem_local,"Local: Verify true and false triggers of on_exit_remove")
RUN(job_core_onexitrem_local)
TESTCLASS(job_core_onexitrem_local,core)
TESTCLASS(job_core_onexitrem_local,quick)
TESTCLASS(job_core_onexitrem_local,full)
TESTCLASS(job_core_onexitrem_local,quicknolink)
TESTCLASS(job_core_onexitrem_local,local)

DESC(job_core_perhold_local,"Local: verify true and false triggers for periodic hold")
RUN(job_core_perhold_local)
TESTCLASS(job_core_perhold_local,core)
TESTCLASS(job_core_perhold_local,quick)
TESTCLASS(job_core_perhold_local,full)
TESTCLASS(job_core_perhold_local,quicknolink)
TESTCLASS(job_core_perhold_local,local)
 
DESC(job_core_perrelease_local,"Local: verify a policy of true/false for periodic release does the right thing")
RUN(job_core_perrelease_local)
TESTCLASS(job_core_perrelease_local,core)
TESTCLASS(job_core_perrelease_local,quick)
TESTCLASS(job_core_perrelease_local,full)
TESTCLASS(job_core_perrelease_local,quicknolink)
TESTCLASS(job_core_perrelease_local,local)

DESC(job_core_perremove_local,"Local: test true/false variations of periodic remove")
RUN(job_core_perremove_local)
TESTCLASS(job_core_perremove_local,core)
TESTCLASS(job_core_perremove_local,quick)
TESTCLASS(job_core_perremove_local,full)
TESTCLASS(job_core_perremove_local,quicknolink)
TESTCLASS(job_core_perremove_local,local)

DESC(job_core_crontab_local,"Local: CronTab Scheduling")
RUN(job_core_crontab_local)
TESTCLASS(job_core_crontab_local,core)
TESTCLASS(job_core_crontab_local,quick)
TESTCLASS(job_core_crontab_local,full)
TESTCLASS(job_core_crontab_local,quicknolink)
TESTCLASS(job_core_crontab_local,local)

DESC(job_core_time-deferral_local,"Local: Verify deferred execution")
RUN(job_core_time-deferral_local)
TESTCLASS(job_core_time-deferral_local,core)
TESTCLASS(job_core_time-deferral_local,quick)
TESTCLASS(job_core_time-deferral_local,full)
TESTCLASS(job_core_time-deferral_local,quicknolink)
TESTCLASS(job_core_time-deferral_local,local)

DESC(job_core_time-deferral-hold_local,"Local: Verify HOLD against deferred execution")
RUN(job_core_time-deferral-hold_local)
TESTCLASS(job_core_time-deferral-hold_local,core)
TESTCLASS(job_core_time-deferral-hold_local,quick)
TESTCLASS(job_core_time-deferral-hold_local,full)
TESTCLASS(job_core_time-deferral-hold_local,quicknolink)
TESTCLASS(job_core_time-deferral-hold_local,local)

DESC(job_core_time-deferral-remove_local,"Local: Verify REMOVE against deferred execution")
RUN(job_core_time-deferral-remove_local)
TESTCLASS(job_core_time-deferral-remove_local,core)
TESTCLASS(job_core_time-deferral-remove_local,quick)
TESTCLASS(job_core_time-deferral-remove_local,full)
TESTCLASS(job_core_time-deferral-remove_local,quicknolink)
TESTCLASS(job_core_time-deferral-remove_local,local)

/* Likely Bugs in Policy matters scheduler Universe */

/*
** 
** Leave Off for now
**
**DESC(job_core_onexitrem_sched,"Scheduler: Verify true and false triggers of on_exit_remove")
**RUN(job_core_onexitrem_sched)
**TESTCLASS(job_core_onexitrem_sched,core)
**TESTCLASS(job_core_onexitrem_sched,quick)
**
**
**DESC(job_core_onexithold_sched,"Scheduler: Verify true and false triggers of on_exit_hold")
**RUN(job_core_onexithold_sched)
**TESTCLASS(job_core_onexithold_sched,core)
**TESTCLASS(job_core_onexithold_sched,quick)
**
*/

/* Likely either test or condor is wrong */

DESC(job_filexfer_basic_van,"Vanilla: send a file and get it back")
RUN(job_filexfer_basic_van)
TESTCLASS(job_filexfer_basic_van,filexfer)
TESTCLASS(job_filexfer_basic_van,quick)
TESTCLASS(job_filexfer_basic_van,full)
TESTCLASS(job_filexfer_basic_van,quicknolink)

DESC(job_filexfer_minus1_van,"Vanilla: extra specified output file creates shadow exception to rerun to produce missing output")
RUN(job_filexfer_minus1_van)
TESTCLASS(job_filexfer_minus1_van,filexfer)
TESTCLASS(job_filexfer_minus1_van,quick)
TESTCLASS(job_filexfer_minus1_van,full)
TESTCLASS(job_filexfer_minus1_van,quicknolink)

DESC(job_filexfer_output-withvacate_van,"Vanilla: 3 files created before vacate - verify their return")
RUN(job_filexfer_output-withvacate_van)
TESTCLASS(job_filexfer_output-withvacate_van,filexfer)
TESTCLASS(job_filexfer_output-withvacate_van,quick)
TESTCLASS(job_filexfer_output-withvacate_van,full)
TESTCLASS(job_filexfer_output-withvacate_van,quicknolink)

/*
**
	Gnats tools/696. Turned off test which expects a shadow exception
	after a job located in a relative location to the submit file
	when filetransfer is set to false. Test job currently runs to success
	so test fails. Exploring correct behaviour. bt
**
**
DESC(job_filexfer_trans-nodflts_van,"Vanilla: all transfers explicitely off - complains...")
RUN(job_filexfer_trans-nodflts_van)
TESTCLASS(job_filexfer_trans-nodflts_van,filexfer)
TESTCLASS(job_filexfer_trans-nodflts_van,quick)
TESTCLASS(job_filexfer_trans-nodflts_van,full)
TESTCLASS(job_filexfer_trans-nodflts_van,quicknolink)
*/

/* Tests which fail in groups but run singly reliably */

/*
** 
** Leave Off for now
**
**DESC(job_core_matchlist_van,"Vanilla: test that match_list_length is storing and rotating matches")
**RUN(job_core_matchlist_van)
**TESTCLASS(job_core_matchlist_van,core)
**TESTCLASS(job_core_matchlist_van,long)
**
**

DESC(job_core_onexitrem_van,"Vanilla: Verify true and false triggers of on_exit_remove")
RUN(job_core_onexitrem_van)
TESTCLASS(job_core_onexitrem_van,core)
TESTCLASS(job_core_onexitrem_van,quick)
TESTCLASS(job_core_onexitrem_van,full)
TESTCLASS(job_core_onexitrem_van,quicknolink)

*/

DESC(job_core_perhold_van,"Vanilla: verify true and false triggers for periodic hold")
RUN(job_core_perhold_van)
TESTCLASS(job_core_perhold_van,core)
TESTCLASS(job_core_perhold_van,quick)
TESTCLASS(job_core_perhold_van,full)
TESTCLASS(job_core_perhold_van,quicknolink)

DESC(job_core_onexithold_van,"Vanilla: Verify true and false triggers of on_exit_hold")
RUN(job_core_onexithold_van)
TESTCLASS(job_core_onexithold_van,core)
TESTCLASS(job_core_onexithold_van,quick)
TESTCLASS(job_core_onexithold_van,full)
TESTCLASS(job_core_onexithold_van,quicknolink)

DESC(job_core_holdrelease_sched,"Scheduler: Test state changes from running to hold to release.")
RUN(job_core_holdrelease_sched)
TESTCLASS(job_core_holdrelease_sched,core)
TESTCLASS(job_core_holdrelease_sched,quick)
TESTCLASS(job_core_holdrelease_sched,full)
TESTCLASS(job_core_holdrelease_sched,quicknolink)


/* runable core coverage tests */

DESC(job_core_args_van,"Vanilla: Did specify args from submit file reach the job?")
RUN(job_core_args_van)
TESTCLASS(job_core_args_van,core)
TESTCLASS(job_core_args_van,quick)
TESTCLASS(job_core_args_van,full)
TESTCLASS(job_core_args_van,quicknolink)

DESC(job_core_args_sched,"scheduler: Did specify args from submit file reach the job?")
RUN(job_core_args_sched)
TESTCLASS(job_core_args_sched,core)
TESTCLASS(job_core_args_sched,quick)
TESTCLASS(job_core_args_sched,full)
TESTCLASS(job_core_args_sched,quicknolink)

#if ! IS_CLIPPED
CBUILD($(CC),job_core_compressfiles,c)
DESC(job_core_compressfiles_std,"Do we handle compressed files made by standard jobs?")
DEPS(job_core_compressfiles_std,job_core_compressfiles.cndr.exe)
RUN(job_core_compressfiles_std)
TESTCLASS(job_core_compressfiles_std,core)
TESTCLASS(job_core_compressfiles_std,quick)
TESTCLASS(job_core_compressfiles_std,full)
TESTCLASS(job_core_compressfiles_std,quicknolink)
#endif /* ! IS_CLIPPED */


/* Hold for now
DESC(job_core_holdrelease_van,"Vanilla: Test state changes from running to hold to release.")
RUN(job_core_holdrelease_van)
TESTCLASS(job_core_holdrelease_van,core)
TESTCLASS(job_core_holdrelease_van,quick)
TESTCLASS(job_core_holdrelease_van,full)
TESTCLASS(job_core_holdrelease_van,quicknolink)

*/

#if !defined(IS_HPUX10)
/*
	GNATS 548 perl md5 module missing on HPUX 10 machine(s)
*/
DESC(job_core_copytospool_van,"Vanilla: test that spooled executable is same via md5 checksum of both files")
RUN(job_core_copytospool_van)
TESTCLASS(job_core_copytospool_van,core)
TESTCLASS(job_core_copytospool_van,quick)
TESTCLASS(job_core_copytospool_van,full)
TESTCLASS(job_core_copytospool_van,quicknolink)
#endif

/*
** too much environment tweaking to have this test on
DESC(job_core_getenv_van,"Vanilla: job which tests getenv both on and off")
RUN(job_core_getenv_van)
TESTCLASS(job_core_getenv_van,core)
TESTCLASS(job_core_getenv_van,long)
TESTCLASS(job_core_getenv_van,full)
*/

DESC(job_core_doublejeopardy_van,"Vanilla: make sure condor does not generate an abort AND the expected abnormal termination.")
RUN(job_core_doublejeopardy_van)
TESTCLASS(job_core_doublejeopardy_van,core)
TESTCLASS(job_core_doublejeopardy_van,quick)
TESTCLASS(job_core_doublejeopardy_van,full)
TESTCLASS(job_core_doublejeopardy_van,quicknolink)

DESC(job_core_doublejeopardy_sched,"Scheduler: make sure condor does not generate an abort AND the expected abnormal termination.")
RUN(job_core_doublejeopardy_sched)
TESTCLASS(job_core_doublejeopardy_sched,core)
TESTCLASS(job_core_doublejeopardy_sched,quick)
TESTCLASS(job_core_doublejeopardy_sched,full)
TESTCLASS(job_core_doublejeopardy_sched,quicknolink)

DESC(job_core_env_sched,"Scheduler: Does environment get to the job")
RUN(job_core_env_sched)
TESTCLASS(job_core_env_sched,core)
TESTCLASS(job_core_env_sched,quick)
TESTCLASS(job_core_env_sched,full)
TESTCLASS(job_core_env_sched,quicknolink)

DESC(job_core_env_van,"Vanilla: Does environment get to the job")
RUN(job_core_env_van)
TESTCLASS(job_core_env_van,core)
TESTCLASS(job_core_env_van,quick)
TESTCLASS(job_core_env_van,full)
TESTCLASS(job_core_env_van,quicknolink)

DESC(job_core_err_sched,"Scheduler: Does requested error file get used?")
RUN(job_core_err_sched)
TESTCLASS(job_core_err_sched,core)
TESTCLASS(job_core_err_sched,quick)
TESTCLASS(job_core_err_sched,full)
TESTCLASS(job_core_err_sched,quicknolink)

DESC(job_core_err_van,"Vanilla: Does requested error file get used?")
RUN(job_core_err_van)
TESTCLASS(job_core_err_van,core)
TESTCLASS(job_core_err_van,quick)
TESTCLASS(job_core_err_van,full)
TESTCLASS(job_core_err_van,quicknolink)
TESTCLASS(job_core_err_van,simple)

DESC(job_core_hold_sched,"Scheduler: job is told to begin on hold. So we test for that state when we get the submitted event")
RUN(job_core_hold_sched)
TESTCLASS(job_core_hold_sched,core)
TESTCLASS(job_core_hold_sched,quick)
TESTCLASS(job_core_hold_sched,full)
TESTCLASS(job_core_hold_sched,quicknolink)

DESC(job_core_hold_van,"Vanilla: job is told to begin on hold. So we test for that state when we get the submitted event")
RUN(job_core_hold_van)
TESTCLASS(job_core_hold_van,core)
TESTCLASS(job_core_hold_van,quick)
TESTCLASS(job_core_hold_van,full)
TESTCLASS(job_core_hold_van,quicknolink)

DESC(job_core_initialdir_sched,"Scheduler: We change the initialdir and assure log and stuff goes there")
RUN(job_core_initialdir_sched)
TESTCLASS(job_core_initialdir_sched,core)
TESTCLASS(job_core_initialdir_sched,quick)
TESTCLASS(job_core_initialdir_sched,full)
TESTCLASS(job_core_initialdir_sched,quicknolink)

DESC(job_core_initialdir_van,"Vanilla: We change the initialdir and assure log and stuff goes there")
RUN(job_core_initialdir_van)
TESTCLASS(job_core_initialdir_van,core)
TESTCLASS(job_core_initialdir_van,quick)
TESTCLASS(job_core_initialdir_van,full)
TESTCLASS(job_core_initialdir_van,quicknolink)

DESC(job_core_remote-initialdir_van,"Vanilla: We change the remote_initialdir and assure the job runs there")
RUN(job_core_remote-initialdir_van)
TESTCLASS(job_core_remote-initialdir_van,core)
TESTCLASS(job_core_remote-initialdir_van,quick)
TESTCLASS(job_core_remote-initialdir_van,full)
TESTCLASS(job_core_remote-initialdir_van,quicknolink)

DESC(job_core_input_sched,"Scheduler: Verify the specified input file is used")
RUN(job_core_input_sched)
TESTCLASS(job_core_input_sched,core)
TESTCLASS(job_core_input_sched,quick)
TESTCLASS(job_core_input_sched,full)
TESTCLASS(job_core_input_sched,quicknolink)

DESC(job_core_input_van,"Vanilla: Verify the specified input file is used")
RUN(job_core_input_van)
TESTCLASS(job_core_input_van,core)
TESTCLASS(job_core_input_van,quick)
TESTCLASS(job_core_input_van,full)
TESTCLASS(job_core_input_van,quicknolink)
TESTCLASS(job_core_input_van,simple)

DESC(job_core_leaveinqueue_sched,"Scheduler: verify true and false classads do leave_in_queue right")
RUN(job_core_leaveinqueue_sched)
TESTCLASS(job_core_leaveinqueue_sched,core)
TESTCLASS(job_core_leaveinqueue_sched,long)
TESTCLASS(job_core_leaveinqueue_sched,full)

DESC(job_core_leaveinqueue_van,"Vanilla: verify true and false classads do leave_in_queue right")
RUN(job_core_leaveinqueue_van)
TESTCLASS(job_core_leaveinqueue_van,core)
TESTCLASS(job_core_leaveinqueue_van,quick)
TESTCLASS(job_core_leaveinqueue_van,full)
TESTCLASS(job_core_leaveinqueue_van,quicknolink)

DESC(job_core_macros_sched,"Scheduler: a number of macros get passed in as args") 
RUN(job_core_macros_sched)
TESTCLASS(job_core_macros_sched,core)
TESTCLASS(job_core_macros_sched,quick)
TESTCLASS(job_core_macros_sched,full)
TESTCLASS(job_core_macros_sched,quicknolink)

DESC(job_core_niceuser_van,"Vanilla: Ensure non nice_user job completes before nice_user job") 
RUN(job_core_niceuser_van)
TESTCLASS(job_core_niceuser_van,core)
TESTCLASS(job_core_niceuser_van,quick)
TESTCLASS(job_core_niceuser_van,full)
TESTCLASS(job_core_niceuser_van,quicknolink)

DESC(job_core_output_sched,"Scheduler: Verify trivially simple output from an input file")
RUN(job_core_output_sched)
TESTCLASS(job_core_output_sched,core)
TESTCLASS(job_core_output_sched,quick)
TESTCLASS(job_core_output_sched,full)
TESTCLASS(job_core_output_sched,quicknolink)

DESC(job_core_output_van,"Vanilla: Verify trivially simple output from an input file")
RUN(job_core_output_van)
TESTCLASS(job_core_output_van,core)
TESTCLASS(job_core_output_van,quick)
TESTCLASS(job_core_output_van,full)
TESTCLASS(job_core_output_van,quicknolink)
TESTCLASS(job_core_output_van,simple)

DESC(job_core_perhold_sched,"Scheduler: verify true and false triggers for periodic hold")
RUN(job_core_perhold_sched)
TESTCLASS(job_core_perhold_sched,core)
TESTCLASS(job_core_perhold_sched,quick)
TESTCLASS(job_core_perhold_sched,full)
TESTCLASS(job_core_perhold_sched,quicknolink)

DESC(job_core_perrelease_sched,"Scheduler: verify a policy of true/false for periodic release does the right thing")
RUN(job_core_perrelease_sched)
TESTCLASS(job_core_perrelease_sched,core)
TESTCLASS(job_core_perrelease_sched,long)
TESTCLASS(job_core_perrelease_sched,full)

DESC(job_core_perrelease_van,"Vanilla: verify a policy of true/false for periodic release does the right thing")
RUN(job_core_perrelease_van)
TESTCLASS(job_core_perrelease_van,core)
TESTCLASS(job_core_perrelease_van,long)
TESTCLASS(job_core_perrelease_van,full)

DESC(job_core_perremove_van,"Vanilla: test true/false variations of periodic remove")
RUN(job_core_perremove_van)
TESTCLASS(job_core_perremove_van,core)
TESTCLASS(job_core_perremove_van,quick)
TESTCLASS(job_core_perremove_van,full)
TESTCLASS(job_core_perremove_van,quicknolink)

DESC(job_core_perremove_sched,"Scheduler: test true/false variations of periodic remove")
RUN(job_core_perremove_sched)
TESTCLASS(job_core_perremove_sched,core)
TESTCLASS(job_core_perremove_sched,quick)
TESTCLASS(job_core_perremove_sched,full)
TESTCLASS(job_core_perremove_sched,quicknolink)

DESC(job_core_plus_van,"Vanilla: Verify +entries go to job ad")
RUN(job_core_plus_van)
TESTCLASS(job_core_plus_van,core)
TESTCLASS(job_core_plus_van,quick)
TESTCLASS(job_core_plus_van,full)
TESTCLASS(job_core_plus_van,quicknolink)

DESC(job_core_plus_sched,"Scheduler: Verify +entries go to job ad")
RUN(job_core_plus_sched)
TESTCLASS(job_core_plus_sched,core)
TESTCLASS(job_core_plus_sched,quick)
TESTCLASS(job_core_plus_sched,full)
TESTCLASS(job_core_plus_sched,quicknolink)

/*
DESC(job_core_priority_van,"Vanilla: Verify respect for job priority")
RUN(job_core_priority_van)
TESTCLASS(job_core_priority_van,core)
TESTCLASS(job_core_priority_van,quick)
TESTCLASS(job_core_priority_van,full)
TESTCLASS(job_core_priority_van,quicknolink)
*/

DESC(job_core_queue_sched,"Scheduler: Verify the  queue command")
RUN(job_core_queue_sched)
TESTCLASS(job_core_queue_sched,core)
TESTCLASS(job_core_queue_sched,quick)
TESTCLASS(job_core_queue_sched,full)
TESTCLASS(job_core_queue_sched,quicknolink)

DESC(job_core_time-deferral_van,"Vanilla: Verify deferred execution")
RUN(job_core_time-deferral_van)
TESTCLASS(job_core_time-deferral_van,core)
TESTCLASS(job_core_time-deferral_van,quick)
TESTCLASS(job_core_time-deferral_van,full)
TESTCLASS(job_core_time-deferral_van,quicknolink)

/*******
 These work but always cause a ShadowException
 Commenting out for for now
 Andy - 02.17.06
 Seem fine now... bt 12.19.08
*********/
DESC(job_core_time-deferral-hold_van,"Vanilla: Verify HOLD against deferred execution")
RUN(job_core_time-deferral-hold_van)
TESTCLASS(job_core_time-deferral-hold_van,core)
TESTCLASS(job_core_time-deferral-hold_van,quick)
TESTCLASS(job_core_time-deferral-hold_van,full)
TESTCLASS(job_core_time-deferral-hold_van,quicknolink)

DESC(job_core_time-deferral-remove_van,"Vanilla: Verify REMOVE against deferred execution")
RUN(job_core_time-deferral-remove_van)
TESTCLASS(job_core_time-deferral-remove_van,core)
TESTCLASS(job_core_time-deferral-remove_van,quick)
TESTCLASS(job_core_time-deferral-remove_van,full)
TESTCLASS(job_core_time-deferral-remove_van,quicknolink)

DESC(job_core_crontab_van,"Vanilla: CronTab Scheduling")
RUN(job_core_crontab_van)
TESTCLASS(job_core_crontab_van,core)
TESTCLASS(job_core_crontab_van,quick)
TESTCLASS(job_core_crontab_van,full)
TESTCLASS(job_core_crontab_van,quicknolink)

DESC(job_core_max-running_local,"Local: Max job running limit")
RUN(job_core_max-running_local)
TESTCLASS(job_core_max-running_local,core)
TESTCLASS(job_core_max-running_local,quick)
TESTCLASS(job_core_max-running_local,full)
TESTCLASS(job_core_max-running_local,quicknolink)
TESTCLASS(job_core_max-running_local,local)

DESC(job_schedd_restart-holdjobs-ok,"Held queue ok after schedd restart")
RUN(job_schedd_restart-holdjobs-ok)
TESTCLASS(job_schedd_restart-holdjobs-ok,core)
TESTCLASS(job_schedd_restart-holdjobs-ok,quick)
TESTCLASS(job_schedd_restart-holdjobs-ok,full)
TESTCLASS(job_schedd_restart-holdjobs-ok,quicknolink)

/*
DESC(job_schedd_restart-runningjobs-ok,"Running queue ok after schedd restart")
RUN(job_schedd_restart-runningjobs-ok)
TESTCLASS(job_schedd_restart-runningjobs-ok,core)
TESTCLASS(job_schedd_restart-runningjobs-ok,quick)
TESTCLASS(job_schedd_restart-runningjobs-ok,full)
TESTCLASS(job_schedd_restart-runningjobs-ok,quicknolink)
*/

/* File Transfer Tests */

DESC(job_filexfer_base-input1_van,"Vanilla: Tests input file does not make it with filetransfer off")
RUN(job_filexfer_base-input1_van)
TESTCLASS(job_filexfer_base-input1_van,filexfer)
TESTCLASS(job_filexfer_base-input1_van,quick)
TESTCLASS(job_filexfer_base-input1_van,full)
TESTCLASS(job_filexfer_base-input1_van,quicknolink)

DESC(job_filexfer_base-input4_van,"Vanilla: Verifies submit fails with input list and with filetransfer off")
RUN(job_filexfer_base-input4_van)
TESTCLASS(job_filexfer_base-input4_van,filexfer)
TESTCLASS(job_filexfer_base-input4_van,quick)
TESTCLASS(job_filexfer_base-input4_van,full)
TESTCLASS(job_filexfer_base-input4_van,quicknolink)

DESC(job_filexfer_base_van,"Vanilla: Is executable moved correctly to initialdir/sandbox?")
RUN(job_filexfer_base_van)
TESTCLASS(job_filexfer_base_van,filexfer)
TESTCLASS(job_filexfer_base_van,quick)
TESTCLASS(job_filexfer_base_van,full)
TESTCLASS(job_filexfer_base_van,quicknolink)

DESC(job_filexfer_input-onegone_van,"Vanilla: test for failure when specified input file is missing")
RUN(job_filexfer_input-onegone_van)
TESTCLASS(job_filexfer_input-onegone_van,filexfer)
TESTCLASS(job_filexfer_input-onegone_van,quick)
TESTCLASS(job_filexfer_input-onegone_van,full)
TESTCLASS(job_filexfer_input-onegone_van,quicknolink)

DESC(job_filexfer_limitback_van,"Vanilla: ask for exactly 2 files returned")
RUN(job_filexfer_limitback_van)
TESTCLASS(job_filexfer_limitback_van,filexfer)
TESTCLASS(job_filexfer_limitback_van,quick)
TESTCLASS(job_filexfer_limitback_van,full)
TESTCLASS(job_filexfer_limitback_van,quicknolink)

DESC(job_filexfer_trans-excut-true_van,"Vanilla: explicitely set transfer_executable... test complains")
RUN(job_filexfer_trans-excut-true_van)
TESTCLASS(job_filexfer_trans-excut-true_van,filexfer)
TESTCLASS(job_filexfer_trans-excut-true_van,quick)
TESTCLASS(job_filexfer_trans-excut-true_van,full)
TESTCLASS(job_filexfer_trans-excut-true_van,quicknolink)

DESC(job_filexfer_whento-base_van,"Vanilla: Inputless test of a job running with transfer files enabled.")
RUN(job_filexfer_whento-base_van)
TESTCLASS(job_filexfer_whento-base_van,filexfer)
TESTCLASS(job_filexfer_whento-base_van,quick)
TESTCLASS(job_filexfer_whento-base_van,full)
TESTCLASS(job_filexfer_whento-base_van,quicknolink)

DESC(job_filexfer_whento-simpleinput_van,"Vanilla: job runs with input file requested")
RUN(job_filexfer_whento-simpleinput_van)
TESTCLASS(job_filexfer_whento-simpleinput_van,filexfer)
TESTCLASS(job_filexfer_whento-simpleinput_van,quick)
TESTCLASS(job_filexfer_whento-simpleinput_van,full)
TESTCLASS(job_filexfer_whento-simpleinput_van,quicknolink)

DESC(job_filexfer_whento-withinput_van,"Vanilla: Multiple input files arrive ok")
RUN(job_filexfer_whento-withinput_van)
TESTCLASS(job_filexfer_whento-withinput_van,filexfer)
TESTCLASS(job_filexfer_whento-withinput_van,quick)
TESTCLASS(job_filexfer_whento-withinput_van,full)
TESTCLASS(job_filexfer_whento-withinput_van,quicknolink)

DESC(job_filexfer_output_van,"Vanilla: Are 6 output files returned")
RUN(job_filexfer_output_van)
TESTCLASS(job_filexfer_output_van,filexfer)
TESTCLASS(job_filexfer_output_van,quick)
TESTCLASS(job_filexfer_output_van,full)
TESTCLASS(job_filexfer_output_van,quicknolink)

#if !defined(IS_HPUX10)
/*
	GNATS 548 perl md5 module missing on HPUX 10 machine(s)
*/
DESC(job_filexfer_md5-remote_van,"Vanilla: Can we move 200 megs and not impact md5 checksum?")
RUN(job_filexfer_md5-remote_van)
TESTCLASS(job_filexfer_md5-remote_van,filexfer)
TESTCLASS(job_filexfer_md5-remote_van,quick)
TESTCLASS(job_filexfer_md5-remote_van,full)
TESTCLASS(job_filexfer_md5-remote_van,quicknolink)
#endif

/* new condor_wait tests */

DESC(cmd_wait_shows-all,"")
DEPS(cmd_wait_shows-all,x_write_joblog_events.exe)
RUN(cmd_wait_shows-all)
TESTCLASS(cmd_wait_shows-all,quick)
TESTCLASS(cmd_wait_shows-all,full)

DESC(cmd_wait_shows-base,"")
DEPS(cmd_wait_shows-base,x_write_joblog_events.exe)
RUN(cmd_wait_shows-base)
TESTCLASS(cmd_wait_shows-base,quick)
TESTCLASS(cmd_wait_shows-base,full)

DESC(cmd_wait_shows-notimeout,"")
DEPS(cmd_wait_shows-notimeout,x_write_joblog_events.exe)
RUN(cmd_wait_shows-notimeout)
TESTCLASS(cmd_wait_shows-notimeout,quick)
TESTCLASS(cmd_wait_shows-notimeout,full)

DESC(cmd_wait_shows-partial,"")
DEPS(cmd_wait_shows-partial,x_write_joblog_events.exe)
RUN(cmd_wait_shows-partial)
TESTCLASS(cmd_wait_shows-partial,quick)
TESTCLASS(cmd_wait_shows-partial,full)

DESC(cmd_wait_shows-timeout,"")
DEPS(cmd_wait_shows-timeout,x_write_joblog_events.exe)
RUN(cmd_wait_shows-timeout)
TESTCLASS(cmd_wait_shows-timeout,quick)
TESTCLASS(cmd_wait_shows-timeout,full)
TESTCLASS(cmd_wait_shows-timeout,quicknolink)
TESTCLASS(cmd_wait_shows-timeout,btdebug)

/* Dagman Tests */

DESC(job_dagman_comlog,"Run a dag with multiple nodes sharing a common log")
DEPS(job_dagman_comlog,x_read_joblog.exe)
RUN(job_dagman_comlog)
TESTCLASS(job_dagman_comlog,dagman)
TESTCLASS(job_dagman_comlog,quick)
TESTCLASS(job_dagman_comlog,full)
TESTCLASS(job_dagman_comlog,quicknolink)

DESC(job_dagman_fullremove,"Ensure a removed dag is completely removed")
DEPS(job_dagman_fullremove,x_read_joblog.exe)
RUN(job_dagman_fullremove)
TESTCLASS(job_dagman_fullremove,dagman)
TESTCLASS(job_dagman_fullremove,quick)
TESTCLASS(job_dagman_fullremove,full)
TESTCLASS(job_dagman_fullremove,quicknolink)

DESC(job_dagman_basic,"Basic one node dag")
RUN(job_dagman_basic)
TESTCLASS(job_dagman_basic,dagman)
TESTCLASS(job_dagman_basic,quick)
TESTCLASS(job_dagman_basic,full)
TESTCLASS(job_dagman_basic,quicknolink)

DESC(job_dagman_maxpostscripts,"Check that throttling by post scripts works")
RUN(job_dagman_maxpostscripts)
TESTCLASS(job_dagman_maxpostscripts,dagman)
TESTCLASS(job_dagman_maxpostscripts,quick)
TESTCLASS(job_dagman_maxpostscripts,full)
TESTCLASS(job_dagman_maxpostscripts,quicknolink)

DESC(job_dagman_maxprescripts,"Check that throttling by pre scripts works")
RUN(job_dagman_maxprescripts)
TESTCLASS(job_dagman_maxprescripts,dagman)
TESTCLASS(job_dagman_maxprescripts,quick)
TESTCLASS(job_dagman_maxprescripts,full)
TESTCLASS(job_dagman_maxprescripts,quicknolink)

DESC(job_dagman_prepost,"Run a dag and verify each nodes pre and post scripts ran")
RUN(job_dagman_prepost)
TESTCLASS(job_dagman_prepost,dagman)
TESTCLASS(job_dagman_prepost,quick)
TESTCLASS(job_dagman_prepost,full)
TESTCLASS(job_dagman_prepost,quicknolink)

DESC(job_dagman_retry,"Make sure a retry dag runs correctly.")
DEPS(job_dagman_retry,x_read_joblog.exe)
RUN(job_dagman_retry)
TESTCLASS(job_dagman_retry,dagman)
TESTCLASS(job_dagman_retry,quick)
TESTCLASS(job_dagman_retry,full)
TESTCLASS(job_dagman_retry,quicknolink)

DESC(job_dagman_throttle,"Test Dagman throttling ability")
DEPS(job_dagman_throttle,x_read_joblog.exe)
RUN(job_dagman_throttle)
TESTCLASS(job_dagman_throttle,dagman)
TESTCLASS(job_dagman_throttle,long)
TESTCLASS(job_dagman_throttle,full)

DESC(job_dagman_uncomlog,"Test Dagmans ability to have sepaarate job log files")
DEPS(job_dagman_uncomlog,x_read_joblog.exe)
RUN(job_dagman_uncomlog)
TESTCLASS(job_dagman_uncomlog,dagman)
TESTCLASS(job_dagman_uncomlog,quick)
TESTCLASS(job_dagman_uncomlog,full)
TESTCLASS(job_dagman_uncomlog,quicknolink)

DESC(job_dagman_unlessexit,"Test that the retries can be stopped with particular exit values from node.")
DEPS(job_dagman_unlessexit,x_read_joblog.exe)
RUN(job_dagman_unlessexit)
TESTCLASS(job_dagman_unlessexit,dagman)
TESTCLASS(job_dagman_unlessexit,quick)
TESTCLASS(job_dagman_unlessexit,full)
TESTCLASS(job_dagman_unlessexit,quicknolink)

DESC(job_dagman_xmlcomlog,"Look at Dagmans ability to handle a common XML based log file")
RUN(job_dagman_xmlcomlog)
TESTCLASS(job_dagman_xmlcomlog,dagman)
TESTCLASS(job_dagman_xmlcomlog,quick)
TESTCLASS(job_dagman_xmlcomlog,full)
TESTCLASS(job_dagman_xmlcomlog,quicknolink)

DESC(job_dagman_xmluncomlog,"Look at Dagmans ability to handle uncommon XML based log files")
RUN(job_dagman_xmluncomlog)
TESTCLASS(job_dagman_xmluncomlog,dagman)
TESTCLASS(job_dagman_xmluncomlog,quick)
TESTCLASS(job_dagman_xmluncomlog,full)
TESTCLASS(job_dagman_xmluncomlog,quicknolink)

DESC(job_dagman_abort-A,"Test ABORT-DAG-ON")
RUN(job_dagman_abort-A)
TESTCLASS(job_dagman_abort-A,dagman)
TESTCLASS(job_dagman_abort-A,quick)
TESTCLASS(job_dagman_abort-A,full)
TESTCLASS(job_dagman_abort-A,quicknolink)

DESC(job_dagman_parallel-A,"Test DAGMan handling nodes w/ multiple jobs")
RUN(job_dagman_parallel-A)
TESTCLASS(job_dagman_parallel-A,dagman)
TESTCLASS(job_dagman_parallel-A,quick)
TESTCLASS(job_dagman_parallel-A,full)
TESTCLASS(job_dagman_parallel-A,quicknolink)

DESC(job_dagman_subdag-A,"Test condor_submit_dag recursion on nested DAGs, SUBDAG EXTERNAL keyword")
RUN(job_dagman_subdag-A)
TESTCLASS(job_dagman_subdag-A,dagman)
TESTCLASS(job_dagman_subdag-A,quick)
TESTCLASS(job_dagman_subdag-A,full)
TESTCLASS(job_dagman_subdag-A,quicknolink)

DESC(job_dagman_splice-cat,"Test DAG splice/node category")
RUN(job_dagman_splice-cat)
TESTCLASS(job_dagman_splice-cat,dagman)
TESTCLASS(job_dagman_splice-cat,quick)
TESTCLASS(job_dagman_splice-cat,full)
TESTCLASS(job_dagman_splice-cat,quicknolink)

DESC(job_dagman_node_prio,"Test DAG node priorities")
RUN(job_dagman_node_prio)
TESTCLASS(job_dagman_node_prio,dagman)
TESTCLASS(job_dagman_node_prio,quick)
TESTCLASS(job_dagman_node_prio,full)
TESTCLASS(job_dagman_node_prio,quicknolink)

DESC(job_dagman_retry_recovery,"Test DAG node priorities")
RUN(job_dagman_retry_recovery)
TESTCLASS(job_dagman_retry_recovery,dagman)
TESTCLASS(job_dagman_retry_recovery,quick)
TESTCLASS(job_dagman_retry_recovery,full)
TESTCLASS(job_dagman_retry_recovery,quicknolink)

/* Sample performance tests */

/*
** Turn off for now.
**
**DESC(perf_busy_lynn_100_100_500_sched,"Generated cpu loading performance test\n");
**RUN(perf_busy_lynn_100_100_500_sched)
**TESTCLASS(perf_busy_lynn_100_100_500_sched,performance)
**TESTCLASS(perf_busy_lynn_100_100_500_sched,long)
**
**DESC(perf_jobs_sue_10_10_30_van,"Generated jobs performance test\n");
**RUN(perf_jobs_sue_10_10_30_van)
**TESTCLASS(perf_jobs_sue_10_10_30_van,performance)
**TESTCLASS(perf_jobs_sue_10_10_30_van,long)
**
**DESC(perf_xfer_deb_10_10_30_van,"Generated transfer performance test\n");
**RUN(perf_xfer_deb_10_10_30_van)
**TESTCLASS(perf_xfer_deb_10_10_30_van,performance)
**TESTCLASS(perf_xfer_deb_10_10_30_van,long)
**
*/

/* Initial top level tests */

DESC(job_filexfer_sandbox-empty_van,"Are job sandboxes with bad permissions cleaned up?")
RUN(job_filexfer_sandbox-empty_van)
TESTCLASS(job_filexfer_sandbox-empty_van,framework)
TESTCLASS(job_filexfer_sandbox-empty_van,quick)
TESTCLASS(job_filexfer_sandbox-empty_van,full)
TESTCLASS(job_filexfer_sandbox-empty_van,quicknolink)

DESC(job_core_sh-loop_van,"Simple vanilla job that loops for N seconds")
RUN(job_core_sh-loop_van)
TESTCLASS(job_core_sh-loop_van,framework)
TESTCLASS(job_core_sh-loop_van,quick)
TESTCLASS(job_core_sh-loop_van,full)
TESTCLASS(job_core_sh-loop_van,quicknolink)

BUILD($(CC),job_core_bigenv,c)
DESC(job_core_bigenv_van,"Vanilla test for enormous environment")
DEPS(job_core_bigenv_van,job_core_bigenv.exe)
RUN(job_core_bigenv_van)
TESTCLASS(job_core_bigenv_van,env)
TESTCLASS(job_core_bigenv_van,framework)
TESTCLASS(job_core_bigenv_van,quick)
TESTCLASS(job_core_bigenv_van,full)
TESTCLASS(job_core_bigenv_van,quicknolink)

DESC(job_core_bigenv_sched,"Scheduler test for enormous environment")
DEPS(job_core_bigenv_sched,job_core_bigenv.exe)
RUN(job_core_bigenv_sched)
TESTCLASS(job_core_bigenv_sched,env)
TESTCLASS(job_core_bigenv_sched,quick)
TESTCLASS(job_core_bigenv_sched,full)
TESTCLASS(job_core_bigenv_sched,quicknolink)

/* NOTE: we want this test in the top-level, even though we're linking
   it for standard universe, since we really don't care about
   different compilers for this one... we just need to see how the
   starter/shadow behave when we drop a core file
   Similarly we want the binary io test here too.
*/
#if ! IS_CLIPPED
CBUILD($(CC),job_core_coredump,c)
DESC(job_core_coredump_std,"Do we handle core files made by standard jobs?")
DEPS(job_core_coredump_std,job_core_coredump.cndr.exe)
RUN(job_core_coredump_std)
TESTCLASS(job_core_coredump_std,framework)
TESTCLASS(job_core_coredump_std,quick)
TESTCLASS(job_core_coredump_std,full)
TESTCLASS(job_core_coredump_std,quicknolink)

CBUILD($(CC),job_rsc_binary-io_std,c)
DESC(job_rsc_binary-io_std,"Do we handle binary io in standard jobs?")
DEPS(job_rsc_binary-io_std,job_rsc_binary-io_std.cndr.exe)
RUN(job_rsc_binary-io_std)
TESTCLASS(job_rsc_binary-io_std,framework)
TESTCLASS(job_rsc_binary-io_std,quick)
TESTCLASS(job_rsc_binary-io_std,full)
TESTCLASS(job_rsc_binary-io_std,quicknolink)
TESTCLASS(job_rsc_binary-io_std,btdebug)

#endif /* ! IS_CLIPPED */
/* This test fails constantly and is off for now
**DESC(job_core_coredump_van,"Do we handle core files made by vanilla jobs?")
**DEPS(job_core_coredump_van,job_core_coredump.exe)
**RUN(job_core_coredump_van)
**TESTCLASS(job_core_coredump_van,framework)
**TESTCLASS(job_core_coredump_van,quick)
*/

lib_eventlog_build.exe : lib_eventlog_base.cpp
	$(CPlusPlus) $< -ggdb -DLIBAPI_ONLY \
	-I ../release_dir/include ../release_dir/lib/libcondorapi.a \
	-lc -ldl -o $@


/************************************************************************
   Settings specific to compiler-specific subdirectories
************************************************************************/

#if ! IS_CLIPPED 

all:: compiler_list

#if HAS_FORTRAN

#if HAS_GNU_G77
/* g77 never has recursion */
F_COMPILER_TARGET(g77,$(GNU_G77),TESTSUITE_FLAGS_G77,0)
#endif

#if HAS_GNU_GFORTRAN
F90_COMPILER_TARGET(gfortran,$(GNU_GFORTRAN),TESTSUITE_FLAGS_GFORTRAN,0)
#endif

#if HAS_VENDOR_F77
F_COMPILER_TARGET(f77,$(VENDOR_F77),TESTSUITE_FLAGS_F77,0)
#endif /* HAS_VENDOR_F77 */

#if HAS_VENDOR_F90
F_COMPILER_TARGET(f90,$(VENDOR_F90),TESTSUITE_FLAGS_F77,0)
#endif

#endif /* HAS_FORTRAN */

/* We always want to build the test suite with gcc and g++ */
C_COMPILER_TARGET(gcc,gcc,TESTSUITE_FLAGS_GCC)

CPP_COMPILER_TARGET(gpp,g++,TESTSUITE_FLAGS_GPP)

/* now, let's see if we've got any vendor compilers */
#if HAS_VENDOR_CC
C_COMPILER_TARGET(cc,$(VENDOR_CC),TESTSUITE_FLAGS_CC)
#endif

#if HAS_VENDOR_CPLUS
CPP_COMPILER_TARGET($(VENDOR_CPLUS_NAME),$(VENDOR_CPLUS),TESTSUITE_FLAGS_CPP)
#endif

#else /* IS_CLIPPED */

compiler_list:
	touch compiler_list

#endif /* ! IS_CLIPPED */

resubmit::
	./x_makeclean.pl

check:: resubmit
	./batch_test.pl -r 1500

check-serialized:: resubmit
	./x_runtests.pl -c quick -t 1200

/***********************************************************************
   Empty rules to make our top-level Imakefile happy
************************************************************************/

html:
release::
stripped::
static::
clean::
testbin::
