 ###############################################################
 # 
 # Copyright 2011 Red Hat, Inc. 
 # 
 # Licensed under the Apache License, Version 2.0 (the "License"); you 
 # may not use this file except in compliance with the License.  You may 
 # obtain a copy of the License at 
 # 
 #    http://www.apache.org/licenses/LICENSE-2.0 
 # 
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and 
 # limitations under the License. 
 # 
 ############################################################### 

############################################################################
## Ok, so in exorcising the unholy daemons in the test goop
## all file generation & manipulation is done in a configure step
## vs. a target. As a result I no longer use safe_append.
if (BUILD_TESTS)

	##########################################################
	# vars and settings
	set(CONDOR_SCRIPTS_DIR ${CONDOR_SOURCE_DIR}/src/condor_scripts)
	include_directories(${CONDOR_SOURCE_DIR}/src/condor_chirp) 

	##########################################################
	## begin file goop manipulation specific to the horror that
	## is the "condor testing framework."
	foreach(scriptFile Condor.pm
			   CondorTest.pm
			   CondorPersonal.pm
			   CondorUtils.pm
			   batch_test.pl)
		configure_file(${CONDOR_SCRIPTS_DIR}/${scriptFile}
				${TEST_TARGET_DIR}/${scriptFile} COPYONLY)
	endforeach(scriptFile)

	# 1st remove generated files.
	file( GLOB RMV_FIRST ${TEST_TARGET_DIR}/list_* *.desc )
	if (RMV_FIRST)
		file( REMOVE ${RMV_FIRST} )
	endif()

	##########################################################
	# exe test targets
	condor_exe_test(x_return-n.exe "x_return-n.cpp;x_waste_second.c" "")
	condor_exe_test(x_dumpcore.exe "x_dumpcore.cpp" "")
	condor_exe_test(x_tightloop.exe "x_tightloop.cpp" "")
	condor_exe_test(x_killppid.exe "x_killppid.cpp" "condorapi")
	condor_exe_test(lib_chirpio.exe "lib_chirpio.cpp" "chirp_client")
	condor_exe_test(job_core_chirp_par.exe "job_core_chirp_par.cpp" "chirp_client")
	condor_exe_test(x_read_joblog.exe "x_read_joblog.cpp" "condorapi")
	condor_exe_test(x_write_joblog.exe "x_write_joblog.cpp" "condorapi")
	condor_exe_test(x_write_joblog_events.exe "x_write_joblog_events.cpp" "condorapi")
	condor_exe_test(lib_eventlog_base.exe "lib_eventlog_base.cpp" "condorapi")
	condor_exe_test(job_core_bigenv.exe "job_core_bigenv.c" "")
	condor_exe_test(lib_eventlog_build.exe "lib_eventlog_base.cpp" "condorapi")
	
	# Not all of our gccs support -Wno-div-by-zero.
	#if (UNIX)
	#	set_source_files_properties(x_dumpcore.cpp PROPERTIES COMPILE_FLAGS -Wno-div-by-zero)
	#endif(UNIX)

	if (NOT WINDOWS)
	  condor_exe_test(x_trapsig.exe "x_trapsig.cpp" "" )
	endif(NOT WINDOWS)
	
	if (STD_UNIVERSE)
		
		# disable any optimizations + compile with specific fla
		set( CMAKE_BUILD_TYPE Debug )
		add_library( stdulib STATIC EXCLUDE_FROM_ALL "x_waste_second.c" )
		add_dependencies( stdulib condorsyscall)
		set( STDU_LDD_FLAGS -lm;-ldl;-lcrypt;libstdulib.a )

		# C-Tests
		if(${SYS_ARCH} MATCHES "X86_64")
			# Only x86_64 machines get to run this test. On 32-bit machines,
			# we still have a 2GB limit for the file size. See gt2337.
			# Mainly, the submit side AND the application both must be 64-bit
			# applications.
			condor_std_exe_test(job_ckpt_lfs_std "${CMAKE_C_COMPILER}" "job_ckpt_lfs_std.c" "${STDU_LDD_FLAGS}")
		endif()

		condor_std_exe_test(job_core_compressfiles "${CMAKE_C_COMPILER}" "job_core_compressfiles.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_core_coredump "${CMAKE_C_COMPILER}" "job_core_coredump.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_binary-io_std "${CMAKE_C_COMPILER}" "job_rsc_binary-io_std.c" "${STDU_LDD_FLAGS}")

		#C++-Tests
		condor_std_exe_test(job_ckpt_constructor_std "${CMAKE_CXX_COMPILER}" "job_ckpt_constructor_std.cpp" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_env_std "${CMAKE_CXX_COMPILER}" "job_ckpt_env_std.cpp" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_memory-file_std "${CMAKE_CXX_COMPILER}" "job_ckpt_memory-file_std.cpp" "${STDU_LDD_FLAGS}")
		
		condor_std_exe_test(job_core-cpp_exception_std "${CMAKE_CXX_COMPILER}" "job_core-cpp_exception_std.cpp" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_core-cpp_mem-alloc_std "${CMAKE_CXX_COMPILER}" "job_core-cpp_mem-alloc_std.cpp" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_fstream_std "${CMAKE_CXX_COMPILER}" "job_rsc_fstream_std.cpp" "${STDU_LDD_FLAGS}")

		# Common to both.  ok so here is my take on this
		# these tests, "test" a function and it is irrelovant whether
		# they were bound via c vs. c++
		condor_std_exe_test(job_core_bigenv "${CMAKE_C_COMPILER}" "job_core_bigenv.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_all-syscalls_std "${CMAKE_C_COMPILER}" "job_rsc_all-syscalls_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_hello_std "${CMAKE_C_COMPILER}" "job_rsc_hello_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_fcntl_std "${CMAKE_C_COMPILER}" "job_rsc_fcntl_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_truncate_std "${CMAKE_C_COMPILER}" "job_rsc_truncate_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_getdirentries_std "${CMAKE_C_COMPILER}" "job_rsc_getdirentries_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_fgets_std "${CMAKE_C_COMPILER}" "job_rsc_fgets_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_fread_std "${CMAKE_C_COMPILER}" "job_rsc_fread_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_ftell_std "${CMAKE_C_COMPILER}" "job_rsc_ftell_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_stat_std "${CMAKE_C_COMPILER}" "job_rsc_stat_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_open-N-serial_std "${CMAKE_C_COMPILER}" "job_rsc_open-N-serial_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_atexit_std "${CMAKE_C_COMPILER}" "job_rsc_atexit_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_rsc_zero-calloc_std "${CMAKE_C_COMPILER}" "job_rsc_zero-calloc_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_combo-sanity_std "${CMAKE_C_COMPILER}" "job_ckpt_combo-sanity_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_io-async_std "${CMAKE_C_COMPILER}" "job_ckpt_io-async_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_io-buffer-async_std "${CMAKE_C_COMPILER}" "job_ckpt_io-buffer-async_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_io-buffer-async-compressed_std "${CMAKE_C_COMPILER}" "job_ckpt_io-buffer-async-compressed_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_stack_std "${CMAKE_C_COMPILER}" "job_ckpt_stack_std.c" "${STDU_LDD_FLAGS}")
		condor_pl_test(job_ckpt_stack_with_ckpt_server_std "Test of checkpoint server" "core;quick;full;quicknolink")
		condor_std_exe_test(job_ckpt_standalone_std "${CMAKE_C_COMPILER}" "job_ckpt_standalone_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_nscd_std "${CMAKE_C_COMPILER}" "job_ckpt_nscd_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_floats_std "${CMAKE_C_COMPILER}" "job_ckpt_floats_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_floats-async_std "${CMAKE_C_COMPILER}" "job_ckpt_floats-async_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_integers_std "${CMAKE_C_COMPILER}" "job_ckpt_integers_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_signals_std "${CMAKE_C_COMPILER}" "job_ckpt_signals_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_dup_std "${CMAKE_C_COMPILER}" "job_ckpt_dup_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_longjmp_std "${CMAKE_C_COMPILER}" "job_ckpt_longjmp_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_gettimeofday_std "${CMAKE_C_COMPILER}" "job_ckpt_gettimeofday_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_open-async-ckpt_std "${CMAKE_C_COMPILER}" "job_ckpt_open-async-ckpt_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_open-N-parallel_std "${CMAKE_C_COMPILER}" "job_ckpt_open-N-parallel_std.c" "${STDU_LDD_FLAGS}")
		condor_std_exe_test(job_ckpt_socket-support_std "${CMAKE_C_COMPILER}" "job_ckpt_socket-support_std.c" "${STDU_LDD_FLAGS}")

		# someone else can add the fortran tests.
		dprint("UW - add fortran .exe tests if desired")
		
		if(${RPM_SYSTEM_NAME} MATCHES "rhel5" AND ${SYS_ARCH} MATCHES "X86_64")
			condor_pl_test(job_ligo_x86-64-chkpttst "Special LIGO test" "core;quick;full;quicknolink")
		endif()
	endif(STD_UNIVERSE)

	##########################################################
	# platform specific tests
	if(LINUX)

		# Openssl on rhel3 doesn't have EVP_sha256(),
		# which the ec2_gahp uses.
		if ( NOT ${SYSTEM_NAME} MATCHES "rhel3" )
			condor_pl_test( job_ec2_basic "EC2 Query API test" "quick;full;quicknolink" )
		endif()

		condor_pl_test(lib_procapi_pidtracking-byenv "Slow Termination Child Cleanup Test" "core;quick;full;quicknolink")
		#condor_pl_test(job_core_shadow-lessthan-memlimit_van "Make sure the shadow stays below memory limit" "core;quick;full;quicknolink")
		if ( WITH_LIBDELTACLOUD AND NOT ${SYSTEM_NAME} MATCHES "rhel3" )
			# This test fails everywhere
			#condor_pl_test(job_deltacloud_basic "Deltacloud test" "core;quick;full;quicknolink")
		endif()
	endif()

	# negative matches. test on everything but this
	if(NOT SOLARIS AND NOT WINDOWS)
		condor_pl_test(job_core_killsignal_sched "Scheduler: Verify the specified input file is used" "core;quick;full;quicknolink")
		condor_pl_test(job_core_rmkillsig_sched "Scheduler: Verify the  remove_kill_sig" "core;quick;full;quicknolink")
	endif()

	if(NOT HPUX)
		condor_pl_test(fetch_work-basic "work fetch smoke test" "core;quick;quicknolink")
		if(HAVE_EXT_OPENSSL)
			condor_pl_test(lib_auth_protocol-ssl "SSL authentication test" "core;quick;full;quicknolink")
		endif()
		#condor_pl_test(lib_auth_protocol-pw "PW authentication test" "core;quick;full;quicknolink")
		#condor_pl_test(lib_auth_protocol-gsi "GSI authentication test" "core;quick;full;quicknolink")
		condor_pl_test(job_dagman_large_dag "Test large DAG w/ recovery mode" "dagman;quick;full;quicknolink")
		condor_pl_test(lib_shared_port_van "Test of shared port feature." "core;quick;full;quicknolink")
		condor_pl_test(lib_shared_port-collector_van "Test of shared port feature with collector usage." "core;quick;full;quicknolink")
		condor_pl_test(lib_shared_port-check-ports_van "Test of shared port feature with respect to open ports." "core;quick;full;quicknolink")
	endif()

	if (NOT AIX)
	  condor_pl_test(lib_procapi_pidtracking-snapshot "Fast Termination Child Cleanup Test" "core;quick;full;quicknolink")
	endif()

	##########################################################
	# feature specific tests
	if (HAVE_VMWARE)
		condor_pl_test(job_vmu_basic "VM Universe smoke test" "core;quick;full;quicknolink")
		# cdrom xfer bits no longer supported. 
		# condor_pl_test(job_vmu_network "VM Universe networking test" "core;quick;full;quicknolink")
		condor_pl_test(job_vmu_ckpt "VM Universe checkpoint test" "core;quick;full;quicknolink")
	endif(HAVE_VMWARE)

	if (STD_UNIVERSE)
		# C-Tests

		if(${SYS_ARCH} MATCHES "X86_64")
			condor_pl_test(job_ckpt_lfs_std "Do we handle files with larger than 32-bit file offsets?" "stduniv;quick;full")
		endif()

		condor_pl_test(job_core_compressfiles_std "Do we handle compressed files made by standard jobs?" "stduniv;core;quick;full")
		condor_pl_test(job_core_coredump_std "Do we handle core files made by standard jobs?" "stduniv;framework;quick;full")
		condor_pl_test(job_rsc_binary-io_std "Do we handle binary io in standard jobs?" "stduniv;framework;quick;full")

		# C++-Tests
		condor_pl_test(job_ckpt_constructor_std "Test C++ global and local constructors" "stduniv;framework;quick;full")
		condor_pl_test(job_ckpt_env_std "Is the environment restored after ckpt?" "stduniv;framework;quick;full")
		condor_pl_test(job_ckpt_memory-file_std "Does the memory_file class work across ckpts?" "stduniv;framework;quick;full")
		condor_pl_test(job_core-cpp_exception_std "C++ exception handling" "framework;quick;full")
		condor_pl_test(job_core-cpp_mem-alloc_std "Memory allocation and constructors" "framework;quick;full")
		condor_pl_test(job_rsc_fstream_std "Does the C++ fstream() interface work?" "stduniv;framework;quick;full")

		# Common to both
		condor_pl_test(job_core_bigenv_std "Standard job with an enormous environment" "framework;quick;full")
		condor_pl_test(job_rsc_all-syscalls_std "Tests nearly all remote syscalls" "stduniv;framework;critical;quick;full;rsc")
		condor_pl_test(job_rsc_hello_std "Tests various RSC I/O methods" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_fcntl_std "Does fcntl() work remotely?" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_truncate_std "Can we truncate files with open() remotely?" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_getdirentries_std "Does getdirentries() work remotely?" "stduniv;quick;full;rsc")
		condor_pl_test(job_rsc_fgets_std "job_rsc_fgets_std" "stduniv;framework;long;full;rsc")
		condor_pl_test(job_rsc_fread_std "Does fread() work remotely?" "stduniv;framework;long;full;rsc")
		condor_pl_test(job_rsc_ftell_std "Does ftell() work remotely?" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_open-N-serial_std "Can we open/close N files in serial?" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_atexit_std "Does atexit() still work?" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_stat_std "Does stat() work remotely?" "stduniv;framework;quick;full;rsc")
		condor_pl_test(job_rsc_zero-calloc_std "Does calloc() allocated zero'ed-out memory?" "stduniv;framework;long;full;rsc")
		condor_pl_test(job_ckpt_combo-sanity_std "combination of sbrk() and register inspection for overall ckpt sanity" "stduniv;long;full;rsc")
		condor_pl_test(job_ckpt_io-async_std "file I/O during async ckpt signals" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_io-buffer-async_std "file buffing during async ckpt/restore" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_io-buffer-async-compressed_std "file buffing during async ckpt/restore with compression" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_stack_std "ckpt/restore function call stack" "stduniv;framework;quick;full;ckpt")
		condor_pl_test(job_ckpt_standalone_std "standalone ckpt/restore function call stack" "stduniv;framework;quick;full;ckpt")
		condor_pl_test(job_ckpt_nscd_std "Test if we handle nscd correctly." "stduniv;framework;quick;full;ckpt")
		condor_pl_test(job_ckpt_floats_std "ckpt/restore floating point registers" "stduniv;framework;quick;full;ckpt")
		condor_pl_test(job_ckpt_floats-async_std "checks floating point ops with async ckpts" "stduniv;framework;quick;full;ckpt")
		condor_pl_test(job_ckpt_integers_std "ckpt/restore integer registers" "stduniv;framework;quick;full;ckpt")
		condor_pl_test(job_ckpt_signals_std "ckpt/restore signal state" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_dup_std "ckpt/restore file table state with dup() calls" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_longjmp_std "Can we ckpt while longjmp()'ing around?" "stduniv;long;full;ckpt")
		condor_pl_test(job_ckpt_gettimeofday_std "ckpt/restore current time-of-day" "stduniv;long;full;ckpt")
		condor_pl_test(job_ckpt_open-async-ckpt_std "async ckpt/restore of open file table" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_open-N-parallel_std "ckpt/restore of N files open at once" "stduniv;quick;full;ckpt")
		#condor_pl_test(job_ckpt_getrusage-loop_std "async ckpt/restore of open file table" "stduniv;quick;full;ckpt")
		condor_pl_test(job_ckpt_socket-support_std "Do we support sockets around ckpt/restore?" "stduniv;long;full;ckpt")

		dprint("UW - add fortran tests if desired")
		
	endif(STD_UNIVERSE)

	##########################################################
	# now all the common tests.
	##### dagman tests
	condor_pl_test(job_core_chirp_par "Exercise the chirp I/O C library in Parallel Universe" "lib;quick;full")
	condor_pl_test(job_dagman_splice-scaling "Dagman Splice Parse Scaling" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-A "Simple Dagman Splice A" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-B "Simple Dagman Splice B" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-C "Simple Dagman Splice C" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-D "Simple Dagman Splice D" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-E "Simple Dagman Splice E" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-F "Simple Dagman Splice F" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-G "Simple Dagman Splice G" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-H "Simple Dagman Splice H" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-I "Simple Dagman Splice I" "core;dagman;quick;full;quicknolink")
	# This test is commented out until we fix Condor.pm to allow multiple dag files to be submitted with condor_submit_dag in TestSubmitDagman
	# condor_pl_test(job_dagman_splice-J "Simple Dagman Splice J" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-K "Simple Dagman Splice K" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-L "Simple Dagman Splice L" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-M "Simple Dagman Splice M" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-N "Simple Dagman Splice N" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-O "Simple Dagman Splice O" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-P "Simple Dagman Splice P" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-Q "Simple Dagman Splice Q" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_pre_skip-A "Simple Dagman Pre Skip A" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_pre_skip-B "Simple Dagman Pre Skip B" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_pre_skip-C "Simple Dagman Pre Skip C" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_always_run_post-A "Always run post A" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_always_run_post-B "Always run post B" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_always_run_post-C "Always run post C" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_always_run_post-D "Always run post D" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_always_run_post-E "Always run post E" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-A "Simple Dagman Final Node A" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-B "Simple Dagman Final Node B" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-C "Simple Dagman Final Node C" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-D "Simple Dagman Final Node D" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-E "Simple Dagman Final Node E" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-F "Simple Dagman Final Node F" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-G "Simple Dagman Final Node G" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-H "Simple Dagman Final Node H" "core;dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_final-I "Simple Dagman Final Node I" "core;dagman;quick;full;quicknolink")
	##### generic lib tests
	condor_pl_test(lib_classads "Run Classad Unit Tests" "core;quick;full;quicknolink")
	condor_pl_test(lib_unit_tests "Run Unit Tests Tests" "core;quick;full;quicknolink")
	condor_pl_test(lib_auth_config "Run Authorization Config Tests" "core;quick;full;quicknolink")
	condor_pl_test(lib_auth_protocol-fs "FS authentication test" "core;quick;full;quicknolink")
	condor_pl_test(lib_auth_protocol-ctb "CTB authentication test" "core;quick;full;quicknolink")
	# Not in use till endurance testing done.
	# condor_pl_test(lib_sysapi "Run SysApi Tests" "core;quick;full;quicknolink")
	# condor_pl_test(lib_procapi "Run ProcApi Tests" "core;quick;full;quicknolink")
	## Disabled due to bugginess and dubious worth
	#condor_pl_test(lib_auth_protocol-negot "4 way negotiation test - frist 8" "core;quick;full;quicknolink")
	#condor_pl_test(lib_auth_protocol-negot-prt2 "4 way negotiation test - last 8" "core;quick;full;quicknolink")
	#condor_pl_test(lib_auth_protocol-negot-prt3 "4 way negotiation test - last 8" "core;quick;full;quicknolink")
	#condor_pl_test(lib_auth_protocol-negot-prt4 "4 way negotiation test - last 8" "core;quick;full;quicknolink")
	##### generic cmd tests
	condor_pl_test(cmd_status_shows-any "Condor_status -any works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-submitters "Condor_status -submitters works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-negotiator "Condor_status -negotiator works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-state "Condor_status -state works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-format "Condor_status -format works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-constraint "Condor_status -constraint works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-avail "Condor_status -avail works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-claim "Condor_status -claim works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-help "Condor_status -help works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-master "Condor_status -master works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-schedd "Condor_status -schedd works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-startd "Condor_status -startd works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_status_shows-absent "Condor_status -absent works as expected" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-dag "Condor_q shows dag" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-hold "Condor_q shows hold" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-run "Condor_q shows runs" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-global "Condor_q shows global" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-name "Condor_q shows name" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-pool "Condor_q shows pool" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-sub "Condor_q shows sub" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-better-analyze "Condor_q shows better-analyze" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-xml "Condor_q shows xml" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-cputime "Condor_q shows cputime" "core;quick;full;quicknolink")
	condor_pl_test(cmd_q_shows-format "Condor_q shows format" "core;quick;full;quicknolink")
	condor_pl_test(file_transfer_submit "condor_submit file transfer" "core;quick;full;quicknolink")

	if (LINUX AND NOT ${SYSTEM_NAME} MATCHES "rhel3")
          condor_pl_test(cmd_ssh_to_job_van "condor_ssh_to_job" "core;quick;full;quicknolink")
	endif()
        condor_pl_test(cmd_drain "condor_drain" "core;quick;full;quicknolink")
        condor_pl_test(defrag "condor_defrag" "core;quick;full;quicknolink")

	##### lib log tests
	condor_pl_test(lib_userlog "Exercise the userlog interface write and read all events" "lib;quick;full")
	condor_pl_test(lib_eventlog "Basic Event Log Test" "core;quick;full")
	condor_pl_test(lib_eventlog-xml "Basic XML Event Log Test" "core;quick;full")
	condor_pl_test(lib_eventlog_base "Test re-initialization of eventlog reader does not cause seg faults" "lib;quick;full")

	# condor_pl_test(job_quill_basic "Basic Quill Test" "core;quick;full;quicknolink")
	# alread built as part of make tests prior to running batch_test

	#dprint("TODO: Need to fix lib_eventlog_rotation-defaults test")
	#condor_pl_test(lib_eventlog_rotation-defaults "Event Log Rotation: Default settings" "core;quick;full")
	condor_pl_test(lib_chirp "Exercise the chirp I/O tool" "lib;quick;full")
	condor_pl_test(lib_chirpio_van "Exercise the chirp I/O library using the C client library" "lib;quick;full")
	condor_pl_test(lib_eventlog_rotation-no_rotations_1 "Event Log Rotation: no rotations/1" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-no_rotations_2 "Event Log Rotation: no rotations/2" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-no_rotations_3 "Event Log Rotation: no rotations/3" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_old_rotations "Event Log Rotation: old rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_old_rotations_2_loops "Event Log Rotation: old rotations / 2 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_2_rotations "Event Log Rotation: 2 rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_2_rotations_2_loops "Event Log Rotation: 2 rotations / 2 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_5_rotations "Event Log Rotation: 5 rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_20_rotations "Event Log Rotation: 20 rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_20_rotations_2_loops "Event Log Rotation: 20 rotations / 2 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-w_20_rotations_20_loops "Event Log Rotation: 20 rotations / 20 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_simple "Event Log Rotation: reader" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_old_rotations "Event Log Rotation: reader, old rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_2_rotations "Event Log Rotation: reader, 2 rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_2_rotations_2_loops "Event Log Rotation: reader, 2 rotations / 2 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_20_rotations "Event Log Rotation: reader, 20 rotations" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_20_rotations_2_loops "Event Log Rotation: reader, 20 rotations / 2 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_20_rotations_20_loops "Event Log Rotation: reader, 20 rotations / 20 loops" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_missed_1 "Event Log Rotation: reader, missed events 1" "core;quick;full")
	condor_pl_test(lib_eventlog_rotation-reader_missed_2 "Event Log Rotation: reader, missed events 2" "core;quick;full")
	##### job tests
	#condor_pl_test(job_had_basic "Basic High Availability Daemon Test" "core;quick;full;quicknolink")
	condor_pl_test(job_core_basic_par "Basic Parallel Universe" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_basic-security_par "Basic Parallel Universe w/security on" "core;quick;full;quicknolink")
	#condor_pl_test(job_stork_file-file "Basic stork Test" "core;quick;full;quicknolink")
	#condor_pl_test(job_dagman_stork_file-file "Basic stork dag Test" "core;dagman;quick;full;quicknolink")
	#condor_pl_test(job_dagman_stork-remove "Basic stork dag w/remove Test" "core;dagman;quick;full;quicknolink")

    if ( ENABLE_JAVA_TESTS )
		condor_pl_test(job_core_err_java "Java Universe: basic error test" "core;quick;full;quicknolink;java")
		condor_pl_test(job_core_output_java "Java Universe: basic output test" "core;quick;full;quicknolink;java")
		condor_pl_test(job_core_hold_java "Java Universe: basic output test" "core;quick;full;quicknolink;java")
		condor_pl_test(job_core_initialdir_java "Java Universe: basic output test" "core;quick;full;quicknolink;java")
		condor_pl_test(job_core_input_java "Java Universe: basic output test" "core;quick;full;quicknolink;java")
		#condor_pl_test(job_core_plus_java "Java Universe: basic output test" "core;quick;full;quicknolink;java")
    endif ( ENABLE_JAVA_TESTS )

	condor_pl_test(job_filexfer_streamout_van "Vanilla: test for streaming of output when both stream_output is true and false" "core;quick;full;quicknolink")
	condor_pl_test(job_filexfer_streamerr_van "Vanilla: test for streaming of error when both stream_error is true and false" "core;quick;full;quicknolink")
	#if !defined( IS_ALPHA_LINUX) && !defined(IS_HPUX10) && !defined(IS_HPUX11) && !defined(IS_IA64_LINUX_RHEL3) 
		condor_pl_test(job_condorc_ab_van "Condor-C AB test" "condorc;quick;full;quicknolink")
		condor_pl_test(job_condorc_abc_van "Condor-C ABC test" "condorc;quick;full;quicknolink")
	#condor_pl_test(lib_procapi_cputracking-snapshot "Scheduler: Verify the specified input file is used" "core;quick;full;quicknolink")
	condor_pl_test(job_core_macros-dollardollar_van "Vanilla: Did dollar dollar macros work?" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_killsignal_van "Vanilla: Verify the specified input file is used" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_corefiles_van "Vanillla limit of core file size - FAILS!" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_corefiles_sched "Scheduler limit of core file size - FAILS!" "core;quick;full;quicknolink")
	condor_pl_test(job_core_onexithold_local "Local: Verify true and false triggers of on_exit_hold" "core;quick;full;quicknolink;local")
	condor_pl_test(job_core_onexitrem_local "Local: Verify true and false triggers of on_exit_remove" "core;quick;full;quicknolink;local")
	condor_pl_test(job_core_perhold_local "Local: verify true and false triggers for periodic hold" "core;quick;full;quicknolink;local")
	condor_pl_test(job_core_perrelease_local "Local: verify a policy of true/false for periodic release does the right thing" "core;quick;full;quicknolink;local")
	condor_pl_test(job_core_perremove_local "Local: test true/false variations of periodic remove" "core;quick;full;quicknolink;local")
	condor_pl_test(job_core_crontab_local "Local: CronTab Scheduling" "core;quick;full;quicknolink;local;time")
	condor_pl_test(job_core_time-deferral_local "Local: Verify deferred execution" "core;quick;full;quicknolink;local;time")
	condor_pl_test(job_core_time-deferral-hold_local "Local: Verify HOLD against deferred execution" "core;quick;full;quicknolink;local;time")
	condor_pl_test(job_core_time-deferral-remove_local "Local: Verify REMOVE against deferred execution" "core;quick;full;quicknolink;local;time")
	#condor_pl_test(job_core_onexitrem_sched "Scheduler: Verify true and false triggers of on_exit_remove" "core;quick")
	#condor_pl_test(job_core_onexithold_sched "Scheduler: Verify true and false triggers of on_exit_hold" "core;quick")
	condor_pl_test(job_filexfer_basic_van "Vanilla: send a file and get it back" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_minus1_van "Vanilla: extra specified output file creates shadow exception to rerun to produce missing output" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_output-withvacate_van "Vanilla: 3 files created before vacate - verify their return" "filexfer;quick;full;quicknolink")
	#condor_pl_test(job_filexfer_trans-nodflts_van,"Vanilla: all transfers explicitely off - complains..." "filexfer;quick;full;quicknolink")
	#condor_pl_test(job_core_matchlist_van "Vanilla: test that match_list_length is storing and rotating matches" "core;quick;full;quicknolink")
	condor_pl_test(job_core_onexitrem_van "Vanilla: Verify true and false triggers of on_exit_remove" "core;quick;full;quicknolink")
	condor_pl_test(job_core_perhold_van "Vanilla: verify true and false triggers for periodic hold" "core;quick;full;quicknolink")
	condor_pl_test(job_core_onexithold_van "Vanilla: Verify true and false triggers of on_exit_hold" "core;quick;full;quicknolink")
	condor_pl_test(job_core_holdrelease_sched "Scheduler: Test state changes from running to hold to release." "core;quick;full;quicknolink")
	condor_pl_test(job_core_args_van "Vanilla: Did specify args from submit file reach the job?" "core;quick;full;quicknolink")
	condor_pl_test(job_core_args_sched "scheduler: Did specify args from submit file reach the job?" "core;quick;full;quicknolink")
	condor_pl_test(job_core_holdrelease_van "Vanilla: Test state changes from running to hold to release." "core;quick;full;quicknolink")
	condor_pl_test(job_core_copytospool_van "Vanilla: test that spooled executable is same via md5 checksum of both files" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_getenv_van "Vanilla: job which tests getenv both on and off" "core;quick;full;quicknolink")
	condor_pl_test(job_core_doublejeopardy_van "Vanilla: make sure condor does not generate an abort AND the expected abnormal termination." "core;quick;full;quicknolink")
	condor_pl_test(job_core_doublejeopardy_sched "Scheduler: make sure condor does not generate an abort AND the expected abnormal termination." "core;quick;full;quicknolink")
	condor_pl_test(job_core_env_sched "Scheduler: Does environment get to the job" "core;quick;full;quicknolink")
	condor_pl_test(job_core_env_van "Vanilla: Does environment get to the job" "core;quick;full;quicknolink")
	condor_pl_test(job_core_err_sched "Scheduler: Does requested error file get used?" "core;quick;full;quicknolink")
	condor_pl_test(job_core_err_van "Vanilla: Does requested error file get used?" "core;quick;full;quicknolink;simple")
	condor_pl_test(job_core_hold_sched "Scheduler: job is told to begin on hold. So we test for that state when we get the submitted event" "core;quick;full;quicknolink")
	condor_pl_test(job_core_hold_van "Vanilla: job is told to begin on hold. So we test for that state when we get the submitted event" "core;quick;full;quicknolink")
	condor_pl_test(job_core_initialdir_sched "Scheduler: We change the initialdir and assure log and stuff goes there" "core;quick;full;quicknolink")
	condor_pl_test(job_core_initialdir_van "Vanilla: We change the initialdir and assure log and stuff goes there" "core;quick;full;quicknolink")
	condor_pl_test(job_core_remote-initialdir_van "Vanilla: We change the remote_initialdir and assure the job runs there" "core;quick;full;quicknolink")
	condor_pl_test(job_core_input_sched "Scheduler: Verify the specified input file is used" "core;quick;full;quicknolink")
	condor_pl_test(job_core_input_van "Vanilla: Verify the specified input file is used" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_leaveinqueue_sched "Scheduler: verify true and false classads do leave_in_queue right" "core;quick;full;quicknolink")
	condor_pl_test(job_core_leaveinqueue_van "Vanilla: verify true and false classads do leave_in_queue right" "core;quick;full;quicknolink")
	condor_pl_test(job_core_macros_sched "Scheduler: a number of macros get passed in as args" "core;quick;full;quicknolink")
	condor_pl_test(job_core_output_sched "Scheduler: Verify trivially simple output from an input file" "core;quick;full;quicknolink")
	condor_pl_test(job_core_output_van "Vanilla: Verify trivially simple output from an input file" "core;quick;full;quicknolink;simple")
	condor_pl_test(job_core_perhold_sched "Scheduler: verify true and false triggers for periodic hold" "core;quick;full;quicknolink")
	condor_pl_test(job_core_perrelease_sched "Scheduler: verify a policy of true/false for periodic release does the right thing" "core;long;full")
	condor_pl_test(job_core_perrelease_van "Vanilla: verify a policy of true/false for periodic release does the right thing" "core;long;full")
	condor_pl_test(job_core_perremove_van "Vanilla: test true/false variations of periodic remove" "core;quick;full;quicknolink")
	condor_pl_test(job_core_perremove_sched "Scheduler: test true/false variations of periodic remove" "core;quick;full;quicknolink")
	condor_pl_test(job_core_plus_van "Vanilla: Verify +entries go to job ad" "core;quick;full;quicknolink")
	condor_pl_test(job_core_plus_sched "Scheduler: Verify +entries go to job ad" "core;quick;full;quicknolink")
	condor_pl_test(job_core_niceuser_van "Vanilla: Ensure non nice_user job completes before nice_user job" "core;quick;full;quicknolink")
	#condor_pl_test(job_core_priority_van "Vanilla: Verify respect for job priority" "core;quick;full;quicknolink")
	condor_pl_test(job_core_queue_sched "Scheduler: Verify the  queue command" "core;quick;full;quicknolink")
	condor_pl_test(job_core_time-deferral_van "Vanilla: Verify deferred execution" "core;quick;full;quicknolink;time")
	condor_pl_test(job_core_time-deferral-hold_van "Vanilla: Verify HOLD against deferred execution" "core;quick;full;quicknolink;time")
	condor_pl_test(job_core_time-deferral-remove_van "Vanilla: Verify REMOVE against deferred execution" "core;quick;full;quicknolink;time")
	condor_pl_test(job_core_crontab_van "Vanilla: CronTab Scheduling" "core;quick;full;quicknolink;time")
	condor_pl_test(job_core_max-running_local "Local: Max job running limit" "core;quick;full;quicknolink;local")
	condor_pl_test(job_schedd_restart-holdjobs-ok "Held queue ok after schedd restart" "core;quick;full;quicknolink")
	#condor_pl_test(job_schedd_restart-runningjobs-ok "Running queue ok after schedd restart" "core;quick;full;quicknolink")
	condor_pl_test(job_filexfer_base-input1_van "Vanilla: Tests input file does not make it with filetransfer off" "filexfer;quick;full;quicknolink")
	# Turn this one back on in 7.7.2 after the file xfer kerfuffle is over
	#condor_pl_test(job_filexfer_base-input4_van "Vanilla: Verifies submit fails with input list and with filetransfer off" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_base_van "Vanilla: Is executable moved correctly to initialdir/sandbox?" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_input-onegone_van "Vanilla: test for failure when specified input file is missing" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_limitback_van "Vanilla: ask for exactly 2 files returned" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_trans-excut-true_van "Vanilla: explicitely set transfer_executable... test complains" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_whento-base_van "Vanilla: Inputless test of a job running with transfer files enabled." "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_whento-simpleinput_van "Vanilla: job runs with input file requested" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_whento-withinput_van "Vanilla: Multiple input files arrive ok" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_output_van "Vanilla: Are 6 output files returned" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_filexfer_md5-remote_van "Vanilla: Can we move 200 megs and not impact md5 checksum?" "filexfer;quick;full;quicknolink")
	condor_pl_test(job_startd_rank_preempt "Does startd rank trump user priority?" "quick;full;quicknolink")
	condor_pl_test(cmd_wait_shows-all "" "quick;full")
	condor_pl_test(cmd_wait_shows-base "" "quick;full")
	condor_pl_test(cmd_wait_shows-notimeout "" "quick;full")
	condor_pl_test(cmd_wait_shows-partial "" "quick;full")
	condor_pl_test(cmd_wait_shows-timeout "" "quick;full")
	condor_pl_test(job_dagman_fullremove "Ensure a removed dag is completely removed" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_basic "Basic one node dag" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_maxpostscripts "Check that throttling by post scripts works" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_maxprescripts "Check that throttling by pre scripts works" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_prepost "Run a dag and verify each nodes pre and post scripts ran" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_retry "Make sure a retry dag runs correctly." "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_throttle "Test Dagman throttling ability" "dagman;long;full")
	condor_pl_test(job_dagman_unlessexit "Test that the retries can be stopped with particular exit values from node." "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_abort-A "Test ABORT-DAG-ON" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_parallel-A "Test DAGMan handling nodes w/ multiple jobs" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_subdag-A "Test condor_submit_dag recursion on nested DAGs, SUBDAG EXTERNAL keyword" "dagman;quick;full;quicknolink")
#   GGT  debug this one later in new batlab
#	condor_pl_test(job_dagman_subdag-AE "Test condor_submit_dag recursion on nested DAGs, SUBDAG EXTERNAL keyword, eager .condor.sub generation" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_subdag_in_splice-A "Test a sub-DAG inside a splice -- only works with lazy submit file generation" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_pre_subdag-A "Test sub-DAG generated by PRE script" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_splice-cat "Test DAG splice/node category" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_node_prio "Test DAG node priorities" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_depth_first "Make sure DAGMan depth-first traversal works" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_log_path "Test DAG tricky log file paths" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_retry_recovery "Test DAG recovery w/ retried node" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_submit_fails_post "Test submit failure on node w/ POST" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_usedagdir "Test DAG with -usedagdir flag" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_node_dir "Test DAG with nodes in subdirectories" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_default_log "Test DAG with default node log file" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_recovery_event_check "Test DAG bad events in recovery mode" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_abnormal_term_recovery_retries "Test DAGMan in recovery mode on abnormally-terminated node job with retries" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_multi_dag "Test DAGMan with multiple DAG files on the command line" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_rescue-A "Test DAGMan with rescue DAG" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_rescue_recov "Test DAGMan with rescue DAG/recovery mode combination" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_event_log "Test DAGMan with event log/POST script combination" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_vars "Test DAG VARS feature" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_script_args "Test pre/post script arguemnts" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_noop_node "Test noop nodes" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_node_status "Test noop nodes" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_job_held "Test removing jobs held too many times" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_reject "Test the REJECT keyword, inside a splice" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_jobstate_log "Test writing the jobstate.log file, including rescue DAG and recovery mode" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_gt1957 "Test gittrac #1957 fix" "dagman;quick;full;quicknolink")
	#condor_pl_test(perf_busy_lynn_100_100_500_sched "Generated cpu loading performance test" "performance;long")
	condor_pl_test(job_dagman_subdag_multi_prohibit-A "Test multi setting prohibiting subdags A" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_subdag_multi_prohibit-B "Test multi setting prohibiting subdags B" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_subdag_multi_prohibit-C "Test multi setting prohibiting subdags C" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_lazy_submit_file "Test lazy submit file creation in DAGMan" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_retry-B "Test node retries in DAGMan" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_propogate_priorities "Test propogation of priorities" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_use_hold_claim "Test holding of claims for DAGman" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_halt-A "Test DAG halting" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_loglink "Test node job user logs as symlinks" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_global_event_log-A "Test behavior in presence of global event log" "dagman;quick;full;quicknolink")
	condor_pl_test(job_dagman_global_event_log-B "Test behavior in presence of global event log" "dagman;quick;full;quicknolink")
	#condor_pl_test(perf_jobs_sue_10_10_30_van "Generated jobs performance test" "performance;long")
	#condor_pl_test(perf_xfer_deb_10_10_30_van "Generated transfer performance test" "performance;long")
	condor_pl_test(job_filexfer_sandbox-empty_van "Are job sandboxes with bad permissions cleaned up?" "framework;quick;full;quicknolink")
	condor_pl_test(job_core_sh-loop_van "Simple vanilla job that loops for N seconds" "framework;quick;full;quicknolink")
	condor_pl_test(job_core_bigenv_van "Vanilla test for enormous environment" "framework;quick;full;quicknolink")
	condor_pl_test(job_core_bigenv_sched "Scheduler test for enormous environment" "framework;quick;full;quicknolink")
	condor_pl_test(lib_ccb_startd "Test of execute daemons using CCB." "core;quick;full;quicknolink")
	condor_pl_test(lib_ccb_schedd "Test of submit daemons using CCB." "core;quick;full;quicknolink")
	condor_pl_test(lib_ccb_schedd_privnet "Test of submit daemons using CCB in private net." "core;quick;full;quicknolink")
	condor_pl_test(lib_job_router_local "Test of JobRouter routing to local universe." "core;quick;full;quicknolink")
	condor_pl_test(condor_view_classad_types "CONDOR_VIEW_CLASSAD_TYPES test" "core;quick;full;quicknolink")
	condor_pl_test(job_partitionable_basic_van "Test basic partitionable slot capability" "core;quick;full;quicknolink")
	condor_pl_test(job_hgq_negfail_basic_van "Test basic Hierarchical Group Quota behavior" "core;quick;full;quicknolink")
	condor_pl_test(job_hgq_autoregroup_basic_van "Test Hierarchical Group Quota autoregroup and group sort" "core;quick;full;quicknolink")

	if ( NOT WITHOUT_SOAP_TEST AND HAVE_EXT_GSOAP )
		condor_pl_test(soap_job_tests "Soap: currently 10 different interface tests" "core;quick;full;quicknolink")
	endif()

endif(BUILD_TESTS)
