FindRuby: Convert tests to RunCMake

Tests/CMakeLists.txt

@@ -1580,10 +1580,6 @@ if(BUILD_TESTING)
     add_subdirectory(UseSWIG)
   endif()
 
-  if(CMake_TEST_FindRuby)
-    add_subdirectory(FindRuby)
-  endif()
-
   add_subdirectory(FindThreads)
 
   # Matlab module

Tests/FindRuby/CMakeLists.txt

@@ -1,71 +0,0 @@
-if(CMake_TEST_FindRuby)
-
-  # Looks for ruby >=1.9.9, which is true on any Ubuntu (that installs it) or macOS (> 10.9)
-  add_test(NAME FindRuby.Test COMMAND
-    ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
-    --build-and-test
-    "${CMake_SOURCE_DIR}/Tests/FindRuby/Test"
-    "${CMake_BINARY_DIR}/Tests/FindRuby/Test"
-    ${build_generator_args}
-    --build-project TestRuby
-    --build-options ${build_options}
-    --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>
-    )
-
-  # Looks for ruby >= 50.1.0, which should logically fail
-  add_test(NAME FindRuby.Fail COMMAND
-    ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
-    --build-and-test
-    "${CMake_SOURCE_DIR}/Tests/FindRuby/Fail"
-    "${CMake_BINARY_DIR}/Tests/FindRuby/Fail"
-    ${build_generator_args}
-    --build-project TestRubyFail
-    --build-options ${build_options}
-    --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>
-    )
-  set_tests_properties(FindRuby.Fail PROPERTIES
-    PASS_REGULAR_EXPRESSION "Could NOT find Ruby.*(Required[ \n]+is[ \n]+at[ \n]+least[ \n]+version[ \n]*\"[0-9]+\\.[0-9]+\\.[0-9]+\")")
-
-  # Looks for 1.9.9 EXACTLY, which unlike the "FindRuby" test above will fail on every machine
-  # since this version doesn't exist (ruby goes from 1.9.3 to 2.0.0)
-  add_test(NAME FindRuby.FailExact COMMAND
-    ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
-    --build-and-test
-    "${CMake_SOURCE_DIR}/Tests/FindRuby/FailExact"
-    "${CMake_BINARY_DIR}/Tests/FindRuby/FailExact"
-    ${build_generator_args}
-    --build-project TestRubyFailExact
-    --build-options ${build_options}
-    --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>
-    )
-  set_tests_properties(FindRuby.FailExact PROPERTIES
-    PASS_REGULAR_EXPRESSION "Could NOT find Ruby.*Required[ \n]+is[ \n]+exact[ \n]+version[ \n]+\"1\\.9\\.9\"")
-
-  # RBENV specific test
-  if(CMake_TEST_FindRuby_RBENV)
-    add_test(NAME FindRuby.Rbenv COMMAND
-      ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
-      --build-and-test
-      "${CMake_SOURCE_DIR}/Tests/FindRuby/Rbenv"
-      "${CMake_BINARY_DIR}/Tests/FindRuby/Rbenv"
-      ${build_generator_args}
-      --build-project TestRBENV
-      --build-options ${build_options}
-      --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>
-      )
-  endif()
-
-  # RVM specific test
-  if(CMake_TEST_FindRuby_RVM)
-    add_test(NAME FindRuby.Rvm COMMAND
-      ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
-      --build-and-test
-      "${CMake_SOURCE_DIR}/Tests/FindRuby/Rvm"
-      "${CMake_BINARY_DIR}/Tests/FindRuby/Rvm"
-      ${build_generator_args}
-      --build-project TestRVM
-      --build-options ${build_options}
-      --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>
-      )
-  endif()
-endif()

Tests/FindRuby/FailExact/CMakeLists.txt

@@ -1,8 +0,0 @@
-cmake_minimum_required(VERSION 3.17)
-project(TestRubyFailExact LANGUAGES NONE)
-
-# Should always fail since there is NO ruby 1.9.9 (goes from 1.9.3 to 2.0.0)
-find_package(Ruby 1.9.9 EXACT REQUIRED)
-if (NOT Ruby_FOUND)
-  message (FATAL_ERROR "Failed to find Ruby 1.9.9")
-endif()

Tests/FindRuby/Rbenv/CMakeLists.txt

@@ -1,77 +0,0 @@
-cmake_minimum_required(VERSION 3.31)
-project(TestRBENV LANGUAGES NONE)
-
-include(CTest)
-
-# Test environment has RBENV_ROOT setup
-find_program (rbenv
-        NAMES rbenv
-        NAMES_PER_DIR
-        PATHS "$ENV{HOME}/.rbenv/bin/rbenv" ENV RBENV_ROOT
-        PATH_SUFFIXES bin Scripts
-        NO_CACHE)
-execute_process (COMMAND "${rbenv}" "which" "ruby"
-        RESULT_VARIABLE result
-        OUTPUT_VARIABLE RBENV_RUBY
-        ERROR_QUIET
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-# Make sure we found a valid Ruby interpreter
-if(NOT RBENV_RUBY)
-  message(FATAL_ERROR "Unable to find RBENV using RBENV_ROOT ${RBENV_ROOT}")
-endif()
-
-# Get the version of rbenv Ruby
-execute_process (COMMAND "${RBENV_RUBY}" -e "puts RUBY_VERSION"
-  RESULT_VARIABLE result
-  OUTPUT_VARIABLE RBENV_RUBY_VERSION
-  ERROR_QUIET
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (result)
-  message (FATAL_ERROR "Unable to detect rbenv ruby version from '${RBENV_RUBY}': ${RBENV_RUBY_VERSION}")
-endif()
-
-# Find system Ruby
-execute_process(COMMAND "${CMAKE_COMMAND}" -E env PATH=/usr/bin:/bin "which" "ruby"
-                RESULT_VARIABLE result
-                OUTPUT_VARIABLE SYSTEM_RUBY
-                ERROR_QUIET
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (SYSTEM_RUBY MATCHES "${RBENV_RUBY}")
-  message(FATAL_ERROR "System Ruby (${SYSTEM_RUBY}) matches rbenv Ruby (${RBENV_RUBY})")
-endif()
-
-# Get version of the system Ruby
-execute_process (COMMAND "${SYSTEM_RUBY}" -e "puts RUBY_VERSION"
-                 RESULT_VARIABLE result
-                 OUTPUT_VARIABLE SYSTEM_RUBY_VERSION
-                 ERROR_QUIET
-                 OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (result)
-  message (FATAL_ERROR "Unable to detect system ruby version from '${SYSTEM_RUBY}': ${SYSTEM_RUBY_VERSION}")
-endif()
-
-if(SYSTEM_RUBY_VERSION VERSION_EQUAL RBENV_RUBY_VERSION)
-  message(FATAL_ERROR "Your RBENV Ruby Version and standard ruby version are the same (${RBENV_RUBY_VERSION}).")
-endif()
-
-message(STATUS "Found standard Ruby (${SYSTEM_RUBY_VERSION}): ${SYSTEM_RUBY}")
-message(STATUS "Found rbenv Ruby (${RBENV_RUBY_VERSION}): ${RBENV_RUBY}")
-
-add_test(NAME FindRuby.RbenvDefault
-        COMMAND "${CMAKE_COMMAND}" -E env "RBENV_ROOT=$ENV{RBENV_ROOT}"
-                "${CMAKE_COMMAND}"  "-DRBENV_RUBY=${RBENV_RUBY}" "-DSYSTEM_RUBY=${SYSTEM_RUBY}" "-DRBENV_RUBY_VERSION=${RBENV_RUBY_VERSION}" "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}"
-                -P "${CMAKE_CURRENT_LIST_DIR}/RbenvDefault.cmake")
-
-add_test(NAME FindRuby.RbenvOnly
-         COMMAND "${CMAKE_COMMAND}" -E env "RBENV_ROOT=$ENV{RBENV_ROOT}"
-                 "${CMAKE_COMMAND}"  "-DRBENV_RUBY=${RBENV_RUBY}" "-DSYSTEM_RUBY=${SYSTEM_RUBY}" "-DRBENV_RUBY_VERSION=${RBENV_RUBY_VERSION}" "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}"
-                 -P "${CMAKE_CURRENT_LIST_DIR}/RbenvOnly.cmake")
-
-add_test(NAME FindRuby.RbenvStandard
-        COMMAND "${CMAKE_COMMAND}" -E env "RBENV_ROOT=$ENV{RBENV_ROOT}"
-                "${CMAKE_COMMAND}"  "-DRBENV_RUBY=${RBENV_RUBY}" "-DSYSTEM_RUBY=${SYSTEM_RUBY}" "-DRBENV_RUBY_VERSION=${RBENV_RUBY_VERSION}" "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}"
-                -P "${CMAKE_CURRENT_LIST_DIR}/RbenvStandard.cmake")

Tests/FindRuby/Rvm/CMakeLists.txt

@@ -1,75 +0,0 @@
-cmake_minimum_required(VERSION 3.17)
-project(TestRVM LANGUAGES NONE)
-
-include(CTest)
-
-# To run this test, you need to have at least one RVM ruby installed
-# and to ensure that the env variable 'MY_RUBY_HOME' is set to a valid RVM ruby when you run the test
-# (which is the case if you have done `rvm use x.y.z`, but could be manually set too)
-
-# Properly using rvm would require sourcing a shell script, eg `source "$HOME/.rvm/scripts/rvm"`
-# Instead, I'll just rely on the env variable MY_RUBY_HOME
-set(MY_RUBY_HOME "$ENV{MY_RUBY_HOME}")
-if(NOT MY_RUBY_HOME)
-  message(FATAL_ERROR "Env variable MY_RUBY_HOME should be set to a valid RVM ruby location, or you should call `rvm use x.y.z` before")
-endif()
-execute_process (COMMAND "${MY_RUBY_HOME}/bin/ruby" -e "puts RUBY_VERSION"
-                 RESULT_VARIABLE result
-                 OUTPUT_VARIABLE RVM_RUBY_VERSION
-                 ERROR_QUIET
-                 OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (result)
-  message (FATAL_ERROR "Unable to detect RVM ruby version from `${MY_RUBY_HOME}/bin/ruby`: ${RVM_RUBY_VERSION}")
-endif()
-
-execute_process(COMMAND "${CMAKE_COMMAND}" -E env --unset=MY_RUBY_HOME PATH=/usr/bin:/bin
-                        "which" "ruby"
-                 RESULT_VARIABLE result
-                 OUTPUT_VARIABLE SYSTEM_RUBY
-                 ERROR_QUIET
-                 OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (SYSTEM_RUBY MATCHES "^${MY_RUBY_HOME}/.+")
-  message(FATAL_ERROR "Unable to find system ruby, found ${SYSTEM_RUBY} which is part of MY_RUBY_HOME=${MY_RUBY_HOME}")
-endif()
-
-# Check version of the system ruby executable.
-execute_process (COMMAND "${SYSTEM_RUBY}" -e "puts RUBY_VERSION"
-                 RESULT_VARIABLE result
-                 OUTPUT_VARIABLE SYSTEM_RUBY_VERSION
-                 ERROR_QUIET
-                 OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (result)
-  message (FATAL_ERROR "Unable to detect system ruby version from '${SYSTEM_RUBY}': ${SYSTEM_RUBY_VERSION}")
-endif()
-
-if(SYSTEM_RUBY_VERSION VERSION_EQUAL RVM_RUBY_VERSION)
-  message(FATAL_ERROR "Your RVM Ruby Version and your System ruby version are the same (${RVM_RUBY_VERSION}).")
-endif()
-
-message("Found System Ruby (${SYSTEM_RUBY_VERSION}): ${SYSTEM_RUBY}")
-message("Found  RVM   Ruby (${RVM_RUBY_VERSION}): ${MY_RUBY_HOME}/bin/ruby")
-
-add_test(NAME FindRuby.RvmDefault
-         COMMAND "${CMAKE_COMMAND}" -E env "MY_RUBY_HOME=${MY_RUBY_HOME}"
-                 "${CMAKE_COMMAND}" "-DRUBY_HOME=${MY_RUBY_HOME}"
-                 -P "${CMAKE_CURRENT_LIST_DIR}/RvmDefault.cmake")
-
-add_test(NAME FindRuby.RvmOnly
-  COMMAND "${CMAKE_COMMAND}" -E env --unset=PATH
-                                    "MY_RUBY_HOME=${MY_RUBY_HOME}"
-          "${CMAKE_COMMAND}" "-DRUBY_HOME=${MY_RUBY_HOME}"
-                 "-DRVM_RUBY_VERSION=${RVM_RUBY_VERSION}" "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}"
-                 -P "${CMAKE_CURRENT_LIST_DIR}/RvmOnly.cmake")
-add_test(NAME FindRuby.UnsetRvmOnly
-         COMMAND "${CMAKE_COMMAND}" -E env --unset=MY_RUBY_HOME "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin"
-                 "${CMAKE_COMMAND}" "-DRVM_RUBY_VERSION=${RVM_RUBY_VERSION}" "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}"
-                 -P "${CMAKE_CURRENT_LIST_DIR}/RvmOnly.cmake")
-
-add_test(NAME FindRuby.RvmStandard
-         COMMAND "${CMAKE_COMMAND}" -E env "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin"
-                                           "MY_RUBY_HOME=${MY_RUBY_HOME}"
-                 "${CMAKE_COMMAND}" "-DRUBY_HOME=${MY_RUBY_HOME}"
-                 -P "${CMAKE_CURRENT_LIST_DIR}/RvmStandard.cmake")

Tests/FindRuby/Rvm/RvmDefault.cmake

@@ -1,17 +0,0 @@
-set(CMAKE_FIND_LIBRARY_PREFIXES "")
-set(CMAKE_FIND_LIBRARY_SUFFIXES "")
-
-find_package (Ruby 2.1.1 REQUIRED)
-if (NOT RUBY_EXECUTABLE MATCHES "^${RUBY_HOME}/.+")
-  message (FATAL_ERROR "Failed to use RVM environment: ${RUBY_EXECUTABLE}, ${RUBY_HOME}")
-endif()
-
-find_package (Ruby 2.1 REQUIRED)
-if (NOT RUBY_EXECUTABLE MATCHES "^${RUBY_HOME}/.+")
-  message (FATAL_ERROR "Failed to use RVM environment: ${RUBY_EXECUTABLE}, ${RUBY_HOME}")
-endif()
-
-find_package (Ruby REQUIRED)
-if (NOT RUBY_EXECUTABLE MATCHES "^${RUBY_HOME}/.+")
-  message (FATAL_ERROR "Failed to use RVM environment: ${RUBY_EXECUTABLE}, ${RUBY_HOME}")
-endif()

Tests/FindRuby/Rvm/RvmStandard.cmake

@@ -1,9 +0,0 @@
-set(CMAKE_FIND_LIBRARY_PREFIXES "")
-set(CMAKE_FIND_LIBRARY_SUFFIXES "")
-
-set (Ruby_FIND_VIRTUALENV STANDARD)
-find_package (Ruby REQUIRED)
-
-if (RUBY_EXECUTABLE MATCHES "^${RUBY_HOME}/.+")
-  message (FATAL_ERROR "RVM ruby unexpectedly found at ${RUBY_EXECUTABLE}, matches ${RUBY_HOME}")
-endif()

Tests/FindRuby/Test/ruby_version.c

@@ -1,7 +0,0 @@
-#include "ruby.h"
-
-int main(void)
-{
-  ruby_show_version();
-  return 0;
-}

Tests/RunCMake/CMakeLists.txt

@@ -498,6 +498,13 @@ if(CMake_TEST_FindPython2 OR CMake_TEST_FindPython2_SABIModule OR CMake_TEST_Fin
 endif()
 add_RunCMake_test(FindBoost)
 add_RunCMake_test(FindLua)
+if(CMake_TEST_FindRuby)
+  add_RunCMake_test(FindRuby
+    -DCMake_TEST_FindRuby_RBENV=${CMake_TEST_FindRuby_RBENV}
+    -DCMake_TEST_FindRuby_RVM=${CMake_TEST_FindRuby_RVM}
+    -DRBENV_ROOT=$ENV{RBENV_ROOT}
+    -DMY_RUBY_HOME=$ENV{MY_RUBY_HOME})
+endif()
 add_RunCMake_test(FindOpenGL)
 add_RunCMake_test(InitialFlags)
 if(CMake_TEST_FindOpenSSL)

Tests/RunCMake/FindRuby/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.20...4.1)
+project(${RunCMake_TEST} NONE)
+include(${RunCMake_TEST}.cmake)

Tests/FindRuby/Rbenv/RbenvStandard.cmake → Tests/RunCMake/FindRuby/Rbenv/RbenvStandard.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_FIND_LIBRARY_PREFIXES "")
 set(CMAKE_FIND_LIBRARY_SUFFIXES "")
 
-set (Ruby_FIND_VIRTUALENV STANDARD)
+set(Ruby_FIND_VIRTUALENV STANDARD)
 unset(ENV{MY_RUBY_HOME}) # Suppress RVM code path for this test.
 
 # We should find the standard Ruby

Tests/RunCMake/FindRuby/RunCMakeTest.cmake

@@ -0,0 +1,159 @@
+include(RunCMake)
+
+# System Ruby tests
+run_cmake(System/Ruby)
+run_cmake(System/Fail)
+run_cmake(System/FailExact)
+
+# RBENV specific tests
+if(CMake_TEST_FindRuby_RBENV)
+  set(ENV{RBENV_ROOT} "${RBENV_ROOT}")
+
+  # Test environment has RBENV_ROOT setup
+  find_program(rbenv
+    NAMES rbenv
+    NAMES_PER_DIR
+    PATHS "$ENV{HOME}/.rbenv/bin" ENV RBENV_ROOT
+    PATH_SUFFIXES bin Scripts
+    NO_CACHE)
+  execute_process(COMMAND "${rbenv}" which ruby
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE RBENV_RUBY
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  # Make sure we found a valid Ruby interpreter
+  if(NOT RBENV_RUBY)
+    message(FATAL_ERROR "Unable to find rbenv Ruby using RBENV_ROOT=${RBENV_ROOT}")
+  endif()
+
+  # Get the version of rbenv Ruby
+  execute_process(COMMAND "${RBENV_RUBY}" -e "puts RUBY_VERSION"
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE RBENV_RUBY_VERSION
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(result)
+    message(FATAL_ERROR "Unable to detect rbenv ruby version from '${RBENV_RUBY}': ${RBENV_RUBY_VERSION}")
+  endif()
+
+  # Find system Ruby
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E env PATH=/usr/bin:/bin which ruby
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE SYSTEM_RUBY
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(SYSTEM_RUBY STREQUAL RBENV_RUBY)
+    message(FATAL_ERROR "System Ruby (${SYSTEM_RUBY}) matches rbenv Ruby (${RBENV_RUBY})")
+  endif()
+
+  # Get version of the system Ruby
+  execute_process(COMMAND "${SYSTEM_RUBY}" -e "puts RUBY_VERSION"
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE SYSTEM_RUBY_VERSION
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(result)
+    message(FATAL_ERROR "Unable to detect system ruby version from '${SYSTEM_RUBY}': ${SYSTEM_RUBY_VERSION}")
+  endif()
+
+  if(SYSTEM_RUBY_VERSION VERSION_EQUAL RBENV_RUBY_VERSION)
+    message(FATAL_ERROR "Your rbenv Ruby version and system Ruby version are the same (${RBENV_RUBY_VERSION}).")
+  endif()
+
+  message(STATUS "Found system Ruby (${SYSTEM_RUBY_VERSION}): ${SYSTEM_RUBY}")
+  message(STATUS "Found rbenv Ruby (${RBENV_RUBY_VERSION}): ${RBENV_RUBY}")
+
+  set(RunCMake_TEST_OPTIONS
+    "-DRBENV_RUBY=${RBENV_RUBY}"
+    "-DSYSTEM_RUBY=${SYSTEM_RUBY}"
+    "-DRBENV_RUBY_VERSION=${RBENV_RUBY_VERSION}"
+    "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}")
+  run_cmake(Rbenv/RbenvDefault)
+  run_cmake(Rbenv/RbenvOnly)
+  run_cmake(Rbenv/RbenvStandard)
+  unset(RunCMake_TEST_OPTIONS)
+endif()
+
+# RVM specific tests
+if(CMake_TEST_FindRuby_RVM)
+  # Properly using rvm would require sourcing a shell script, eg `source "$HOME/.rvm/scripts/rvm"`
+  # Instead, we just rely on the env variable MY_RUBY_HOME
+  if(NOT MY_RUBY_HOME)
+    message(FATAL_ERROR "MY_RUBY_HOME should be set to a valid RVM ruby location, or you should call `rvm use x.y.z` before")
+  endif()
+
+  set(ENV{MY_RUBY_HOME} "${MY_RUBY_HOME}")
+
+  execute_process(COMMAND "${MY_RUBY_HOME}/bin/ruby" -e "puts RUBY_VERSION"
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE RVM_RUBY_VERSION
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(result)
+    message(FATAL_ERROR "Unable to detect RVM ruby version from '${MY_RUBY_HOME}/bin/ruby': ${RVM_RUBY_VERSION}")
+  endif()
+
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E env --unset=MY_RUBY_HOME PATH=/usr/bin:/bin which ruby
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE SYSTEM_RUBY
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(SYSTEM_RUBY MATCHES "^${MY_RUBY_HOME}")
+    message(FATAL_ERROR "Unable to find system ruby, found ${SYSTEM_RUBY} which is part of MY_RUBY_HOME=${MY_RUBY_HOME}")
+  endif()
+
+  # Check version of the system ruby executable.
+  execute_process(COMMAND "${SYSTEM_RUBY}" -e "puts RUBY_VERSION"
+    RESULT_VARIABLE result
+    OUTPUT_VARIABLE SYSTEM_RUBY_VERSION
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(result)
+    message(FATAL_ERROR "Unable to detect system ruby version from '${SYSTEM_RUBY}': ${SYSTEM_RUBY_VERSION}")
+  endif()
+
+  if(SYSTEM_RUBY_VERSION VERSION_EQUAL RVM_RUBY_VERSION)
+    message(FATAL_ERROR "Your RVM Ruby version and system Ruby version are the same (${RVM_RUBY_VERSION}).")
+  endif()
+
+  message(STATUS "Found system Ruby (${SYSTEM_RUBY_VERSION}): ${SYSTEM_RUBY}")
+  message(STATUS "Found RVM Ruby (${RVM_RUBY_VERSION}): ${MY_RUBY_HOME}/bin/ruby")
+
+  set(ORIGINAL_PATH "$ENV{PATH}")
+
+  # RvmDefault - just MY_RUBY_HOME set
+  set(RunCMake_TEST_OPTIONS "-DMY_RUBY_HOME=${MY_RUBY_HOME}")
+  run_cmake(Rvm/RvmDefault)
+
+  # RvmOnly - PATH unset, MY_RUBY_HOME set
+  unset(ENV{PATH})
+  set(RunCMake_TEST_OPTIONS
+    "-DMY_RUBY_HOME=${MY_RUBY_HOME}"
+    "-DRVM_RUBY_VERSION=${RVM_RUBY_VERSION}"
+    "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}")
+  run_cmake(Rvm/RvmOnly)
+
+  # UnsetRvmOnly - MY_RUBY_HOME unset, PATH set to minimal
+  unset(ENV{MY_RUBY_HOME})
+  set(ENV{PATH} "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
+  set(RunCMake_TEST_OPTIONS
+    "-DRVM_RUBY_VERSION=${RVM_RUBY_VERSION}"
+    "-DSYSTEM_RUBY_VERSION=${SYSTEM_RUBY_VERSION}")
+  run_cmake(Rvm/UnsetRvmOnly)
+
+  # RvmStandard - PATH minimal, MY_RUBY_HOME set
+  set(ENV{MY_RUBY_HOME} "${MY_RUBY_HOME}")
+  set(RunCMake_TEST_OPTIONS "-DMY_RUBY_HOME=${MY_RUBY_HOME}")
+  run_cmake(Rvm/RvmStandard)
+
+  # Restore PATH
+  set(ENV{PATH} "${ORIGINAL_PATH}")
+  unset(RunCMake_TEST_OPTIONS)
+endif()

Tests/RunCMake/FindRuby/Rvm/RvmDefault.cmake

@@ -0,0 +1,17 @@
+set(CMAKE_FIND_LIBRARY_PREFIXES "")
+set(CMAKE_FIND_LIBRARY_SUFFIXES "")
+
+find_package (Ruby 2.1.1 REQUIRED)
+if (NOT Ruby_EXECUTABLE MATCHES "^${RUBY_HOME}")
+  message (FATAL_ERROR "Failed to use RVM environment: ${Ruby_EXECUTABLE}, ${RUBY_HOME}")
+endif()
+
+find_package (Ruby 2.1 REQUIRED)
+if (NOT Ruby_EXECUTABLE MATCHES "^${RUBY_HOME}")
+  message (FATAL_ERROR "Failed to use RVM environment: ${Ruby_EXECUTABLE}, ${RUBY_HOME}")
+endif()
+
+find_package (Ruby REQUIRED)
+if (NOT Ruby_EXECUTABLE MATCHES "^${MY_RUBY_HOME}")
+  message (FATAL_ERROR "Failed to use RVM environment: ${Ruby_EXECUTABLE}, ${MY_RUBY_HOME}")
+endif()

Tests/FindRuby/Rvm/RvmOnly.cmake → Tests/RunCMake/FindRuby/Rvm/RvmOnly.cmake

@@ -5,7 +5,7 @@ set(Ruby_FIND_VIRTUALENV ONLY)
 set(Ruby_RBENV_EXECUTABLE "") # Suppress rbenv code path for this test.
 
 # Test: FindRuby.RvmOnly
-if (RUBY_HOME)
+if (MY_RUBY_HOME)
   # => Trying to find exactly system ruby using ONLY virtual environment should fail
   find_package (Ruby ${SYSTEM_RUBY_VERSION} EXACT QUIET)
   if(Ruby_FOUND)
@@ -20,7 +20,7 @@ endif()
 
 
 # Test: FindRuby.UnsetRvmOnly
-if (NOT RUBY_HOME)
+if (NOT MY_RUBY_HOME)
 
   # If ENV{MY_RUBY_HOME} isn't defined and Ruby_FIND_VIRTUALENV is set to ONLY
   # then Ruby should not be found

Tests/RunCMake/FindRuby/Rvm/RvmStandard.cmake

@@ -0,0 +1,9 @@
+set(CMAKE_FIND_LIBRARY_PREFIXES "")
+set(CMAKE_FIND_LIBRARY_SUFFIXES "")
+
+set (Ruby_FIND_VIRTUALENV STANDARD)
+find_package (Ruby REQUIRED)
+
+if (Ruby_EXECUTABLE MATCHES "^${MY_RUBY_HOME}")
+  message (FATAL_ERROR "RVM ruby unexpectedly found at ${Ruby_EXECUTABLE}, matches ${MY_RUBY_HOME}")
+endif()

Tests/RunCMake/FindRuby/Rvm/UnsetRvmOnly.cmake

@@ -0,0 +1,37 @@
+set(CMAKE_FIND_LIBRARY_PREFIXES "")
+set(CMAKE_FIND_LIBRARY_SUFFIXES "")
+
+set(Ruby_FIND_VIRTUALENV ONLY)
+set(Ruby_RBENV_EXECUTABLE "") # Suppress rbenv code path for this test.
+
+# Test: FindRuby.RvmOnly
+if (MY_RUBY_HOME)
+  # => Trying to find exactly system ruby using ONLY virtual environment should fail
+  find_package (Ruby ${SYSTEM_RUBY_VERSION} EXACT QUIET)
+  if(Ruby_FOUND)
+    message (FATAL_ERROR "Ruby unexpectedly found.")
+  endif()
+  # And should work to find the rvm version
+  find_package (Ruby ${RVM_RUBY_VERSION} EXACT QUIET)
+  if(Ruby_FOUND)
+    message (FATAL_ERROR "Ruby unexpectedly found.")
+  endif()
+endif()
+
+
+# Test: FindRuby.UnsetRvmOnly
+if (NOT MY_RUBY_HOME)
+  # If ENV{MY_RUBY_HOME} isn't defined and Ruby_FIND_VIRTUALENV is set to ONLY
+  # then Ruby should not be found
+
+  find_package (Ruby ${RVM_RUBY_VERSION} EXACT QUIET)
+  if(Ruby_FOUND)
+    message (FATAL_ERROR "RVM Ruby unexpectedly found.")
+  endif()
+
+  # it should *not* find the system ruby
+  find_package (Ruby ${SYSTEM_RUBY_VERSION} EXACT QUIET)
+  if(Ruby_FOUND)
+    message (FATAL_ERROR "Ruby unexpectedly found.")
+  endif()
+endif()

Tests/RunCMake/FindRuby/System/Fail-result.txt

@@ -0,0 +1 @@
+1

Tests/RunCMake/FindRuby/System/Fail-stderr.txt

@@ -0,0 +1 @@
+Could NOT find Ruby \(missing:[^)]*\) \(Required[^)]*"50\.1\.0"\)

Tests/FindRuby/Fail/CMakeLists.txt → Tests/RunCMake/FindRuby/System/Fail.cmake

@@ -1,5 +1,2 @@
-cmake_minimum_required(VERSION 3.17)
-project(TestRubyFail LANGUAGES NONE)
-
 # Should always fail since there is NO ruby 50.1.0 yet.
 find_package(Ruby 50.1.0 REQUIRED)

Tests/RunCMake/FindRuby/System/FailExact-result.txt

@@ -0,0 +1 @@
+1

Tests/RunCMake/FindRuby/System/FailExact-stderr.txt

@@ -0,0 +1 @@
+Could NOT find Ruby \(missing:[^)]*\) \(Required[^)]*"1\.9\.9"\)

Tests/RunCMake/FindRuby/System/FailExact.cmake

@@ -0,0 +1,2 @@
+# Should always fail since there is NO ruby 1.9.9 (goes from 1.9.3 to 2.0.0)
+find_package(Ruby 1.9.9 EXACT REQUIRED)

Tests/FindRuby/Test/CMakeLists.txt → Tests/RunCMake/FindRuby/System/Ruby.cmake

@@ -1,9 +1,9 @@
-cmake_minimum_required(VERSION 3.17)
-project(TestRuby LANGUAGES C)
-include(CTest)
+enable_language(C)
 
 cmake_policy(SET CMP0185 NEW)
 
+set(Ruby_RBENV_EXECUTABLE "") # Suppress rbenv code path for this test.
+
 find_package(Ruby 1.9.9 REQUIRED)
 if (NOT Ruby_FOUND)
   message (FATAL_ERROR "Failed to find Ruby >=1.9.9")
@@ -19,9 +19,3 @@ foreach(var_CMP0185
     message(FATAL_ERROR "Pre-CMP0185 result variable is set: ${var_CMP0185}")
   endif()
 endforeach()
-
-add_executable(ruby_version ruby_version.c)
-target_include_directories(ruby_version PRIVATE ${Ruby_INCLUDE_DIRS})
-target_link_libraries(ruby_version PRIVATE ${Ruby_LIBRARIES})
-
-add_test(NAME ruby_version COMMAND ruby_version)