CTest: Rename hardware -> resources for RunCMake tests

Also includes variants like hw -> res

Tests/RunCMake/CMakeLists.txt

@@ -335,7 +335,7 @@ add_RunCMake_test(no_install_prefix)
 add_RunCMake_test(configure_file)
 add_RunCMake_test(CTestTimeoutAfterMatch)
 
-# cthwalloc links against CMakeLib and CTestLib, which means it can't be built
+# ctresalloc links against CMakeLib and CTestLib, which means it can't be built
 # if CMake_TEST_EXTERNAL_CMAKE is activated (the compiler might be different.)
 # So, it has to be provided in the original build tree.
 if(CMake_TEST_EXTERNAL_CMAKE)
@@ -343,7 +343,7 @@ if(CMake_TEST_EXTERNAL_CMAKE)
   if(NOT CMAKE_VERSION VERSION_LESS 3.12)
     set(no_package_root_path NO_PACKAGE_ROOT_PATH)
   endif()
-  find_program(cthwalloc cthwalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE}
+  find_program(ctresalloc ctresalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE}
     NO_DEFAULT_PATH
     ${no_package_root_path}
     NO_CMAKE_PATH
@@ -352,25 +352,25 @@ if(CMake_TEST_EXTERNAL_CMAKE)
     NO_CMAKE_SYSTEM_PATH
     NO_CMAKE_FIND_ROOT_PATH
     )
-  if(cthwalloc)
-    add_executable(cthwalloc IMPORTED)
-    set_property(TARGET cthwalloc PROPERTY IMPORTED_LOCATION ${cthwalloc})
+  if(ctresalloc)
+    add_executable(ctresalloc IMPORTED)
+    set_property(TARGET ctresalloc PROPERTY IMPORTED_LOCATION ${ctresalloc})
   endif()
 else()
-  add_executable(cthwalloc CTestHardwareAllocation/cthwalloc.cxx)
-  target_link_libraries(cthwalloc CTestLib)
-  target_include_directories(cthwalloc PRIVATE
+  add_executable(ctresalloc CTestResourceAllocation/ctresalloc.cxx)
+  target_link_libraries(ctresalloc CTestLib)
+  target_include_directories(ctresalloc PRIVATE
     ${CMake_BINARY_DIR}/Source
     ${CMake_SOURCE_DIR}/Source
     ${CMake_SOURCE_DIR}/Source/CTest
     )
-  set_property(TARGET cthwalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR})
+  set_property(TARGET ctresalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR})
 endif()
 
-if(TARGET cthwalloc)
-  add_RunCMake_test(CTestHardwareAllocation -DCTHWALLOC_COMMAND=$<TARGET_FILE:cthwalloc>)
+if(TARGET ctresalloc)
+  add_RunCMake_test(CTestResourceAllocation -DCTRESALLOC_COMMAND=$<TARGET_FILE:ctresalloc>)
 else()
-  message(WARNING "Could not find or build cthwalloc")
+  message(WARNING "Could not find or build ctresalloc")
 endif()
 
 find_package(Qt4 QUIET)

Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake

-function(setup_hardware_tests)
-  if(CTEST_HARDWARE_ALLOC_ENABLED)
-    add_test(NAME HardwareSetup COMMAND "${CMAKE_COMMAND}" -E remove -f "${CMAKE_BINARY_DIR}/cthwalloc.log")
-  endif()
-endfunction()
-
-function(add_hardware_test name sleep_time proc)
-  if(CTEST_HARDWARE_ALLOC_ENABLED)
-    add_test(NAME "${name}" COMMAND "${CTHWALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/cthwalloc.log" "${name}" "${sleep_time}" "${proc}")
-    set_property(TEST "${name}" PROPERTY DEPENDS HardwareSetup)
-  else()
-    add_test(NAME "${name}" COMMAND "${CTHWALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/cthwalloc.log" "${name}" "${sleep_time}")
-  endif()
-  set_property(TEST "${name}" PROPERTY RESOURCE_GROUPS "${proc}")
-  list(APPEND HARDWARE_TESTS "${name}")
-  set(HARDWARE_TESTS "${HARDWARE_TESTS}" PARENT_SCOPE)
-endfunction()
-
-function(cleanup_hardware_tests)
-  if(CTEST_HARDWARE_ALLOC_ENABLED)
-    file(WRITE "${CMAKE_BINARY_DIR}/hwtests.txt" "${HARDWARE_TESTS}")
-  endif()
-endfunction()

Tests/RunCMake/CTestHardwareAllocation/checkfree1-ctest-s-hw-check.cmake

-verify_ctest_hardware()

Tests/RunCMake/CTestHardwareAllocation/checkfree1.cmake

-setup_hardware_tests()
-
-add_hardware_test(Test1 1 "widgets:8")
-add_hardware_test(Test2 1 "fluxcapacitors:50;fluxcapacitors:50,widgets:8")
-add_hardware_test(Test3 1 "fluxcapacitors:121")
-
-cleanup_hardware_tests()

Tests/RunCMake/CTestHardwareAllocation/checkfree2-ctest-s-hw-check.cmake

-verify_ctest_hardware()

Tests/RunCMake/CTestHardwareAllocation/checkfree2.cmake

-setup_hardware_tests()
-
-# This test is an attack on the hardware scheduling algorithm. It has been
-# carefully crafted to fool the algorithm into thinking there isn't sufficient
-# hardware for it.
-add_hardware_test(Test1 1 "widgets:2;4,widgets:4")
-
-cleanup_hardware_tests()

Tests/RunCMake/CTestHardwareAllocation/lotsoftests-ctest-s-hw-check.cmake

-verify_ctest_hardware()

Tests/RunCMake/CTestHardwareAllocation/lotsoftests.cmake

-setup_hardware_tests()
-
-add_hardware_test(Test1 2 "widgets:8;2,widgets:2")
-add_hardware_test(Test2 5 "fluxcapacitors:40")
-add_hardware_test(Test3 1 "10,widgets:1,fluxcapacitors:2")
-add_hardware_test(Test4 4 "fluxcapacitors:121")
-
-foreach(i RANGE 5 50)
-  add_hardware_test(Test${i} 1 "2,widgets:1")
-endforeach()
-
-foreach(i RANGE 51 100)
-  add_hardware_test(Test${i} 1 "2,transmogrifiers:2")
-endforeach()
-
-cleanup_hardware_tests()

Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-check.cmake

-if(EXISTS "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log")
-  set(RunCMake_TEST_FAILED "cthwalloc.log should not exist")
-endif()

Tests/RunCMake/CTestHardwareAllocation/notenough1.cmake

-setup_hardware_tests()
-
-add_hardware_test(Test1 1 "fluxcapacitors:200")
-
-cleanup_hardware_tests()

Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-check.cmake

-if(EXISTS "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log")
-  set(RunCMake_TEST_FAILED "cthwalloc.log should not exist")
-endif()

Tests/RunCMake/CTestHardwareAllocation/notenough2.cmake

-setup_hardware_tests()
-
-add_hardware_test(Test1 1 "terminators:2")
-
-cleanup_hardware_tests()

Tests/RunCMake/CTestHardwareAllocation/process_count-ctest-s-hw-check.cmake

-verify_ctest_hardware()

Tests/RunCMake/CTestHardwareAllocation/process_count.cmake

-setup_hardware_tests()
-
-add_hardware_test(Test1 1 "widgets:1")
-
-cleanup_hardware_tests()

Tests/RunCMake/CTestHardwareAllocation/CMakeLists.txt.in → Tests/RunCMake/CTestResourceAllocation/CMakeLists.txt.in

@@ -4,6 +4,6 @@ if(CASE_NAME MATCHES "^(.*)-ctest-s")
   set(projname "${CMAKE_MATCH_1}")
   project(${projname} NONE)
   include(CTest)
-  include("@RunCMake_SOURCE_DIR@/HardwareCommon.cmake")
+  include("@RunCMake_SOURCE_DIR@/ResourceCommon.cmake")
   include("@RunCMake_SOURCE_DIR@/${projname}.cmake")
 endif()

Tests/RunCMake/CTestResourceAllocation/ResourceCommon.cmake

+function(setup_resource_tests)
+  if(CTEST_RESOURCE_ALLOC_ENABLED)
+    add_test(NAME ResourceSetup COMMAND "${CMAKE_COMMAND}" -E remove -f "${CMAKE_BINARY_DIR}/ctresalloc.log")
+  endif()
+endfunction()
+
+function(add_resource_test name sleep_time proc)
+  if(CTEST_RESOURCE_ALLOC_ENABLED)
+    add_test(NAME "${name}" COMMAND "${CTRESALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/ctresalloc.log" "${name}" "${sleep_time}" "${proc}")
+    set_property(TEST "${name}" PROPERTY DEPENDS ResourceSetup)
+  else()
+    add_test(NAME "${name}" COMMAND "${CTRESALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/ctresalloc.log" "${name}" "${sleep_time}")
+  endif()
+  set_property(TEST "${name}" PROPERTY RESOURCE_GROUPS "${proc}")
+  list(APPEND RESOURCE_TESTS "${name}")
+  set(RESOURCE_TESTS "${RESOURCE_TESTS}" PARENT_SCOPE)
+endfunction()
+
+function(cleanup_resource_tests)
+  if(CTEST_RESOURCE_ALLOC_ENABLED)
+    file(WRITE "${CMAKE_BINARY_DIR}/restests.txt" "${RESOURCE_TESTS}")
+  endif()
+endfunction()

Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake → Tests/RunCMake/CTestResourceAllocation/RunCMakeTest.cmake

@@ -2,53 +2,53 @@ include(RunCMake)
 include(RunCTest)
 
 ###############################################################################
-# Test cthwalloc itself - we want to make sure it's not just rubber-stamping
+# Test ctresalloc itself - we want to make sure it's not just rubber-stamping
 # the test results
 ###############################################################################
 
-function(cthwalloc_verify_log expected_contents)
-  if(NOT EXISTS "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log")
+function(ctresalloc_verify_log expected_contents)
+  if(NOT EXISTS "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log")
     string(APPEND RunCMake_TEST_FAILED "Log file was not written\n")
     set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
     return()
   endif()
-  file(READ "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log" actual_contents)
+  file(READ "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log" actual_contents)
   if(NOT actual_contents STREQUAL expected_contents)
     string(APPEND RunCMake_TEST_FAILED "Actual log did not match expected log\n")
     set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
   endif()
 endfunction()
 
-function(run_cthwalloc_write_proc name proc)
-  file(REMOVE "${RunCMake_BINARY_DIR}/${name}-build/cthwalloc.log")
-  run_cthwalloc_write_proc_nodel("${name}" "${proc}" "${ARGN}")
+function(run_ctresalloc_write_proc name proc)
+  file(REMOVE "${RunCMake_BINARY_DIR}/${name}-build/ctresalloc.log")
+  run_ctresalloc_write_proc_nodel("${name}" "${proc}" "${ARGN}")
 endfunction()
 
-function(run_cthwalloc_write_proc_nodel name proc)
+function(run_ctresalloc_write_proc_nodel name proc)
   string(REPLACE ";" "\\;" proc "${proc}")
-  run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTHWALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/cthwalloc.log" "${name}" 0 "${proc}")
+  run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTRESALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/ctresalloc.log" "${name}" 0 "${proc}")
 endfunction()
 
-function(run_cthwalloc_write_noproc name)
-  run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTHWALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/cthwalloc.log" "${name}" 0)
+function(run_ctresalloc_write_noproc name)
+  run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTRESALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/ctresalloc.log" "${name}" 0)
 endfunction()
 
-function(run_cthwalloc_verify name tests)
+function(run_ctresalloc_verify name tests)
   string(REPLACE ";" "\\;" tests "${tests}")
-  run_cmake_command(${name} "${CTHWALLOC_COMMAND}" verify "${RunCMake_SOURCE_DIR}/${name}.log" "${CMAKE_CURRENT_LIST_DIR}/hwspec.json" "${tests}")
+  run_cmake_command(${name} "${CTRESALLOC_COMMAND}" verify "${RunCMake_SOURCE_DIR}/${name}.log" "${CMAKE_CURRENT_LIST_DIR}/resspec.json" "${tests}")
 endfunction()
 
 unset(ENV{CTEST_RESOURCE_GROUP_COUNT})
 set(RunCMake_TEST_NO_CLEAN 1)
-file(REMOVE_RECURSE "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build")
-file(MAKE_DIRECTORY "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build")
-file(WRITE "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build/cthwalloc.log"
+file(REMOVE_RECURSE "${RunCMake_BINARY_DIR}/ctresalloc-write-proc-good1-build")
+file(MAKE_DIRECTORY "${RunCMake_BINARY_DIR}/ctresalloc-write-proc-good1-build")
+file(WRITE "${RunCMake_BINARY_DIR}/ctresalloc-write-proc-good1-build/ctresalloc.log"
 [[begin test1
 alloc widgets 0 1
 dealloc widgets 0 1
 end test1
 ]])
-run_cthwalloc_write_proc_nodel(cthwalloc-write-proc-good1 "1,widgets:2,transmogrifiers:1;2,widgets:1,widgets:2"
+run_ctresalloc_write_proc_nodel(ctresalloc-write-proc-good1 "1,widgets:2,transmogrifiers:1;2,widgets:1,widgets:2"
   CTEST_RESOURCE_GROUP_COUNT=3
   CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers
   CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2
@@ -59,95 +59,95 @@ run_cthwalloc_write_proc_nodel(cthwalloc-write-proc-good1 "1,widgets:2,transmogr
   "CTEST_RESOURCE_GROUP_2_WIDGETS=id:0,slots:1\\;id:2,slots:2"
   )
 set(RunCMake_TEST_NO_CLEAN 0)
-run_cthwalloc_write_proc(cthwalloc-write-proc-good2 "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-good2 "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-nocount "widgets:8")
-run_cthwalloc_write_proc(cthwalloc-write-proc-badcount "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-nocount "widgets:8")
+run_ctresalloc_write_proc(ctresalloc-write-proc-badcount "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=2
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-nores "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-nores "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badres "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badres "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-nowidgets "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-nowidgets "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets1 "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets1 "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   CTEST_RESOURCE_GROUP_0_WIDGETS=
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets2 "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets2 "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   "CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8\\;id:0,slots:1"
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets3 "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets3 "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:7
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets4 "widgets:8"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets4 "widgets:8"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   CTEST_RESOURCE_GROUP_0_WIDGETS=invalid
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets5 "widgets:2,widgets:2"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets5 "widgets:2,widgets:2"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1"
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets6 "widgets:2"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets6 "widgets:2"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1"
   )
-run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets7 "widgets:2,widgets:2"
+run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets7 "widgets:2,widgets:2"
   CTEST_RESOURCE_GROUP_COUNT=1
   CTEST_RESOURCE_GROUP_0=widgets
   CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2
   )
 
-run_cthwalloc_write_noproc(cthwalloc-write-noproc-good1)
-run_cthwalloc_write_noproc(cthwalloc-write-noproc-count
+run_ctresalloc_write_noproc(ctresalloc-write-noproc-good1)
+run_ctresalloc_write_noproc(ctresalloc-write-noproc-count
   CTEST_RESOURCE_GROUP_COUNT=1
   )
 
-run_cthwalloc_verify(cthwalloc-verify-good1 "test1;test2")
-run_cthwalloc_verify(cthwalloc-verify-good2 "")
-run_cthwalloc_verify(cthwalloc-verify-nolog "")
-run_cthwalloc_verify(cthwalloc-verify-nores "")
-run_cthwalloc_verify(cthwalloc-verify-noid "")
-run_cthwalloc_verify(cthwalloc-verify-notenough "")
-run_cthwalloc_verify(cthwalloc-verify-baddealloc "")
-run_cthwalloc_verify(cthwalloc-verify-leak "")
-run_cthwalloc_verify(cthwalloc-verify-badtest1 "")
-run_cthwalloc_verify(cthwalloc-verify-badtest2 "test1")
-run_cthwalloc_verify(cthwalloc-verify-badtest3 "test1")
-run_cthwalloc_verify(cthwalloc-verify-badtest4 "test1")
-run_cthwalloc_verify(cthwalloc-verify-badtest5 "test1")
-run_cthwalloc_verify(cthwalloc-verify-nobegin "test1")
-run_cthwalloc_verify(cthwalloc-verify-noend "test1")
+run_ctresalloc_verify(ctresalloc-verify-good1 "test1;test2")
+run_ctresalloc_verify(ctresalloc-verify-good2 "")
+run_ctresalloc_verify(ctresalloc-verify-nolog "")
+run_ctresalloc_verify(ctresalloc-verify-nores "")
+run_ctresalloc_verify(ctresalloc-verify-noid "")
+run_ctresalloc_verify(ctresalloc-verify-notenough "")
+run_ctresalloc_verify(ctresalloc-verify-baddealloc "")
+run_ctresalloc_verify(ctresalloc-verify-leak "")
+run_ctresalloc_verify(ctresalloc-verify-badtest1 "")
+run_ctresalloc_verify(ctresalloc-verify-badtest2 "test1")
+run_ctresalloc_verify(ctresalloc-verify-badtest3 "test1")
+run_ctresalloc_verify(ctresalloc-verify-badtest4 "test1")
+run_ctresalloc_verify(ctresalloc-verify-badtest5 "test1")
+run_ctresalloc_verify(ctresalloc-verify-nobegin "test1")
+run_ctresalloc_verify(ctresalloc-verify-noend "test1")
 
 ###############################################################################
-# Now test the hardware allocation feature of CTest
+# Now test the resource allocation feature of CTest
 ###############################################################################
 
-function(run_ctest_hardware name parallel random)
-  run_ctest("${name}-ctest-s-hw" "-DCTEST_HARDWARE_ALLOC_ENABLED=1" "-DCTHWALLOC_COMMAND=${CTHWALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}")
-  run_ctest("${name}-ctest-s-nohw" "-DCTEST_HARDWARE_ALLOC_ENABLED=0" "-DCTHWALLOC_COMMAND=${CTHWALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}")
+function(run_ctest_resource name parallel random)
+  run_ctest("${name}-ctest-s-res" "-DCTEST_RESOURCE_ALLOC_ENABLED=1" "-DCTRESALLOC_COMMAND=${CTRESALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}")
+  run_ctest("${name}-ctest-s-nores" "-DCTEST_RESOURCE_ALLOC_ENABLED=0" "-DCTRESALLOC_COMMAND=${CTRESALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}")
 endfunction()
 
-function(verify_ctest_hardware)
-  file(READ "${RunCMake_TEST_BINARY_DIR}/hwtests.txt" hwtests)
-  execute_process(COMMAND "${CTHWALLOC_COMMAND}" verify "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log" "${CMAKE_CURRENT_LIST_DIR}/hwspec.json" "${hwtests}"
+function(verify_ctest_resources)
+  file(READ "${RunCMake_TEST_BINARY_DIR}/restests.txt" restests)
+  execute_process(COMMAND "${CTRESALLOC_COMMAND}" verify "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log" "${CMAKE_CURRENT_LIST_DIR}/resspec.json" "${restests}"
     OUTPUT_VARIABLE output ERROR_QUIET RESULT_VARIABLE result)
   if(result)
     string(APPEND RunCMake_TEST_FAILED "${output}")
@@ -155,13 +155,13 @@ function(verify_ctest_hardware)
   endif()
 endfunction()
 
-run_ctest_hardware(lotsoftests 10 1)
-run_ctest_hardware(checkfree1 2 0)
-run_ctest_hardware(checkfree2 1 0)
-run_ctest_hardware(notenough1 1 0)
-run_ctest_hardware(notenough2 1 0)
-run_ctest_hardware(ensure_parallel 2 0)
+run_ctest_resource(lotsoftests 10 1)
+run_ctest_resource(checkfree1 2 0)
+run_ctest_resource(checkfree2 1 0)
+run_ctest_resource(notenough1 1 0)
+run_ctest_resource(notenough2 1 0)
+run_ctest_resource(ensure_parallel 2 0)
 
 set(ENV{CTEST_RESOURCE_GROUP_COUNT} 2)
-run_ctest_hardware(process_count 1 0)
+run_ctest_resource(process_count 1 0)
 unset(ENV{CTEST_RESOURCE_GROUP_COUNT})

Tests/RunCMake/CTestResourceAllocation/checkfree1-ctest-s-res-check.cmake

+verify_ctest_resources()

Tests/RunCMake/CTestResourceAllocation/checkfree1.cmake

+setup_resource_tests()
+
+add_resource_test(Test1 1 "widgets:8")
+add_resource_test(Test2 1 "fluxcapacitors:50;fluxcapacitors:50,widgets:8")
+add_resource_test(Test3 1 "fluxcapacitors:121")
+
+cleanup_resource_tests()

Tests/RunCMake/CTestResourceAllocation/checkfree2-ctest-s-res-check.cmake

+verify_ctest_resources()

Tests/RunCMake/CTestResourceAllocation/checkfree2.cmake

+setup_resource_tests()
+
+# This test is an attack on the resource scheduling algorithm. It has been
+# carefully crafted to fool the algorithm into thinking there aren't sufficient
+# resources for it.
+add_resource_test(Test1 1 "widgets:2;4,widgets:4")
+
+cleanup_resource_tests()

Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good1-check.cmake → Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good1-check.cmake

-cthwalloc_verify_log(
+ctresalloc_verify_log(
 [[begin test1
 alloc widgets 0 1
 dealloc widgets 0 1
 end test1
-begin cthwalloc-write-proc-good1
+begin ctresalloc-write-proc-good1
 alloc transmogrifiers calvin 1
 alloc widgets 0 2
 alloc widgets 0 1
@@ -16,5 +16,5 @@ dealloc widgets 0 1
 dealloc widgets 2 2
 dealloc widgets 0 1
 dealloc widgets 2 2
-end cthwalloc-write-proc-good1
+end ctresalloc-write-proc-good1
 ]])

Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good2-check.cmake → Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good2-check.cmake

-cthwalloc_verify_log(
-[[begin cthwalloc-write-proc-good2
+ctresalloc_verify_log(
+[[begin ctresalloc-write-proc-good2
 alloc widgets 3 8
 dealloc widgets 3 8
-end cthwalloc-write-proc-good2
+end ctresalloc-write-proc-good2
 ]])

Tests/RunCMake/CTestHardwareAllocation/ensure_parallel-ctest-s-hw-check.cmake → Tests/RunCMake/CTestResourceAllocation/ensure_parallel-ctest-s-res-check.cmake

-verify_ctest_hardware()
+verify_ctest_resources()
 
 set(expected_contents [[
 begin Test1
@@ -10,7 +10,7 @@ end Test1
 dealloc transmogrifiers hobbes 2
 end Test2