[CMake] Deal with semicolons in ENV passed to RootTestDriver

The processing of the environment variables in the RootTestDriver used
excessive CMake string-to-list parsing, and the semicolons would have to
be escaped for each of these parsings. That means the RootTestDriver
command needed to include a magic number amount of escape characters to
propagate semicolons to the final environment variables.

The fix is to escape semicolons once in the beginning, and then
re-escape them after each step that involves list parsing.

Like this, the command can contain just bare semicolons without having
to escape anything.

In a next step, one can consider giving the same treatment to the
`ROOT_ADD_TEST` macro, which also does excessive list parsing. Then we
don't need tricks like the `$<SEMICOLON>` generator expression anymore
to propagate semicolons into the final command.

Author: guitargeek

cmake/modules/RootTestDriver.cmake

@@ -72,12 +72,33 @@ endif()
 
 #---Set environment --------------------------------------------------------------------------------
 if(ENV)
-  string(REPLACE "#" ";" _env ${ENV})
+  # CMake treats ';' as a list separator. Since ENV values may legitimately
+  # contain semicolons (e.g. PATH-like variables), we must escape them here
+  # so they survive the upcoming list expansion in `foreach()`.
+  string(REPLACE ";" "\\;" _env "${ENV}")
+
+  # Deserialize the ENV string into a CMake list.
+  # This is the inverse operation of ROOT_ADD_TEST, which serializes the list
+  # by joining elements with '#'.
+  string(REPLACE "#" ";" _env "${_env}")
+
   foreach(pair ${_env})
-    string(REGEX REPLACE "^([^=]+)=(.*)$" "\\1;\\2" pair ${pair})
+
+    # During list expansion, CMake has already consumed any previous '\;'
+    # escaping. Re-escape semicolons so the key=value split below treats the
+    # value as a single string.
+    string(REPLACE ";" "\\;" pair "${pair}")
+
+    # Split KEY=VALUE into a 2-element CMake list: [KEY;VALUE]
+    string(REGEX REPLACE "^([^=]+)=(.*)$" "\\1;\\2" pair "${pair}")
+
     list(GET pair 0 var)
     list(GET pair 1 val)
-    set(ENV{${var}} ${val})
+
+    # As before, quoting is important here so the semicolons are not
+    # interpreted as list separators.
+    set(ENV{${var}} "${val}")
+
     if(DBG)
       message(STATUS "testdriver[ENV]:${var}==>${val}")
     endif()

tutorials/CMakeLists.txt

@@ -17,16 +17,17 @@ set(root_includepaths
     ${DEFAULT_ROOT_INCLUDE_PATH}
 )
 cmake_path(CONVERT "${root_includepaths}" TO_NATIVE_PATH_LIST root_includepaths_native)
+set(root_includepaths_native "${CMAKE_BINARY_DIR}/tutorials/io/tree;${CMAKE_BINARY_DIR}/runtutorials")
 
-# The environment argument gets serialized in ROOT_ADD_TEST for the
-# RootTestDriver, and then deserialized in the latter with multiple steps of
-# string parsing. We have to escape the semicolon excessively, because in every
-# parsing step we lose one semicolon. Also we use the SEMICOLON generator
-# expression, so at least we don't have to worry about escaping for the initial
-# configuration stage.
-# TODO: consider improving ROOT_ADD_TEST and RootTestDriver.cmake so this is not necessary.
-string(REPLACE ";" "\\\\\\\\$<SEMICOLON>" pythonpaths_escaped "${pythonpaths_native}")
-string(REPLACE ";" "\\\\\\\\$<SEMICOLON>" root_includepaths_escaped "${root_includepaths_native}")
+# Use the $<SEMICOLON> generator expression to defer semicolon expansion until
+# generator-expression evaluation. This avoids CMake interpreting literal ';'
+# as list separators during argument handling.
+#
+# ROOT_ADD_TEST performs multiple string-to-list conversions when serializing
+# the test command, which makes it unsafe to pass literal semicolons in
+# arguments until this behavior is fixed.
+string(REPLACE ";" "$<SEMICOLON>" pythonpaths_escaped "${pythonpaths_native}")
+string(REPLACE ";" "$<SEMICOLON>" root_includepaths_escaped "${root_includepaths_native}")
 
 # - Set the environment for the tutorials, which also contains some environment
 # variables related to limiting the number of threads used by NumPy and