Merge remote-tracking branch 'cgal/master' into Triangulation_3-CDT_3-lrineau

# Conflicts:
#	Installation/CHANGES.md

Scripts/developer_scripts/autotest_cgal_with_ctest

@@ -9,11 +9,6 @@ export SHOW_PROGRESS=""
 export KEEP_TESTS=""
 export DO_NOT_UPLOAD=""
 export DO_NOT_TEST=""
-export SCP="scp"
-export WGET="wget"
-export WGET_OPTS="--no-check-certificate --no-verbose"
-export CURL="curl"
-export CURL_OPTS="-k --remote-name --silent --location-trusted"
 export CGAL_URL="https://cgal.geometryfactory.com/CGAL/Releases"
 export UPLOAD_RESULT_DESTINATION="cgaltest@cgaltest.geometryfactory.com:incoming"
 export UPLOAD_DEMOS_DESTINATION="cgaltest@cgaltest.geometryfactory.com:public_html/incoming"
@@ -22,7 +17,8 @@ export TAR="tar"
 export GUNZIP="gunzip"
 export COMPRESSOR="gzip"
 export CONSOLE_OUTPUT="y"
-export CGAL_HOME=$(pwd | sed -E 's/\/cygdrive\/([a-z])\//\U\1:\//')
+CGAL_HOME=$(pwd | sed -E 's/\/cygdrive\/([a-z])\//\U\1:\//')
+export CGAL_HOME
 export USE_TARGZ="y"
 export USE_TARBZ="n"
 export CGAL_RELEASE=""
@@ -34,14 +30,10 @@ export INSTALLATION_DIR=""
 export TESTSUITE_DIR=""
 USE_LATEST_UNZIPPED=""
 
-# ----------------------------------------------------------------------------------------
-# produce a string containing the actual date/time
-#  (used to identify files)
-# ----------------------------------------------------------------------------------------
-datestr()
-{
-  date +%d%m%Y%H%M
-}
+WGET="wget"
+WGET_OPTS=(--no-check-certificate --no-verbose)
+CURL="curl"
+CURL_OPTS=(-k --remote-name --silent --location-trusted)
 
 # ----------------------------------------------------------------------------------------
 # Logging functions
@@ -51,11 +43,13 @@ log()
   LOGFILE=${1}
   shift
   if [ -n "${CONSOLE_OUTPUT}" ]; then
-      printf "${*} ...\n"
+      printf "%s ...\n" "${*}"
   fi
-  printf "\n-------------------------------------------------------\n" >> "${LOGFILE}"
-  printf "  ${*} ...\n"                                                >> "${LOGFILE}"
-  printf "\n-------------------------------------------------------\n" >> "${LOGFILE}"
+  {
+    printf "\n-------------------------------------------------------\n"
+    printf "  %s ...\n" "$*"
+    printf "\n-------------------------------------------------------\n"
+  } >> "${LOGFILE}"
 }
 
 log_done()
@@ -64,30 +58,42 @@ log_done()
       printf \
       " done\n-------------------------------------------------------\n"
   fi
-  printf "\n-------------------------------------------------------\n" >> "${1}"
-  printf "  **DONE**\n"                                                >> "${1}"
-  printf "\n-------------------------------------------------------\n" >> "${1}"
+  {
+    printf "\n-------------------------------------------------------\n"
+    printf "  **DONE**\n"
+    printf "\n-------------------------------------------------------\n"
+  } >> "${1}"
 }
 
 error()
 {
   if [ -n "${CONSOLE_OUTPUT}" ]; then
-      printf "\nERROR: ${*}, exiting.\n" >&2
+      printf "\nERROR: %s, exiting.\n" "$*" >&2
   fi
-  printf "\nERROR: ${*}, exiting.\n" >> "${ACTUAL_LOGFILE}"
-  ${COMPRESSOR} -9f "${ACTUAL_LOGFILE}"
-  FILENAME="${CGAL_RELEASE_ID}-log`datestr`.gz"
-  mv "${ACTUAL_LOGFILE}.gz" "${LOGS_DIR}/${FILENAME}"
-  if [ ! "${MAIL_ADDRESS}" = "must_be_set_in_.autocgalrc" ]; then
-    for i in ${MAIL_ADDRESS}; do
-      printf "ERROR\n${LOGS_DIR}/${FILENAME}\n" | \
-          ${SENDMAIL} -s "completed autotest" "${i}"
+  printf "\nERROR: %s, exiting.\n" "$*" >> "$ACTUAL_LOGFILE"
+  "$COMPRESSOR" -9f "$ACTUAL_LOGFILE"
+  FILENAME="${CGAL_RELEASE_ID}-log$(date_str).gz"
+  mv "${ACTUAL_LOGFILE}.gz" "$LOGS_DIR/$FILENAME"
+  if [ ! "$MAIL_ADDRESS" = "must_be_set_in_.autocgalrc" ]; then
+    for i in $MAIL_ADDRESS; do
+      printf "ERROR\n%s\n" "$LOGS_DIR/$FILENAME" | \
+          "$SENDMAIL" -s "completed autotest" "$i"
     done
   fi
-  rm -rf "$LOCK_FILE";
+  rm -rf "$LOCK_FILE"
   exit 1
 }
 
+# ----------------------------------------------------------------------------------------
+# produce a string containing the actual date/time
+#  (used to identify files)
+# ----------------------------------------------------------------------------------------
+date_str()
+{
+  date +%d%m%Y%H%M
+}
+
+
 # ----------------------------------------------------------------------------------------
 # Downloads the file "LATEST" whose contents indicates which release to test
 # ----------------------------------------------------------------------------------------
@@ -96,14 +102,8 @@ download_latest()
   if [ -r "LATEST" ]; then
     rm -rf LATEST
   fi
-    log "${ACTUAL_LOGFILE}" "getting LATEST"
-    if [ -n "${USE_CURL}" ]; then
-      echo "using curl..."
-      ${CURL} ${CURL_OPTS} "${LATEST_LOCATION}" >> "${ACTUAL_LOGFILE}" 2>&1
-    else
-      echo "using wget..."
-      ${WGET} ${WGET_OPTS} "${LATEST_LOCATION}" >> "${ACTUAL_LOGFILE}" 2>&1
-    fi
+  log "$ACTUAL_LOGFILE" "getting LATEST"
+  download_file "$LATEST_LOCATION" >> "$ACTUAL_LOGFILE" 2>&1
   if [ ! -f "LATEST" ]; then
     error "COULD NOT DOWNLOAD LATEST!"
   fi
@@ -133,40 +133,34 @@ abort_if_latest_already_tested()
 get_cgal()
 {
   if [ -z "$CGAL_LOCATION" ]; then
-    for i in `cat LATEST`
-    do
-      CGAL_LOCATION="${CGAL_URL}/${i}";
-      CGAL_ZIPFILE="${i}";
-    done
+    while IFS= read -r i; do
+      CGAL_LOCATION="${CGAL_URL}/$i"
+      CGAL_ZIPFILE="$i"
+    done < LATEST
   else
-    CGAL_ZIPFILE=`echo "$CGAL_LOCATION" | sed 's|.*/||'`
+    CGAL_ZIPFILE="${CGAL_LOCATION##*/}"
   fi
 
-  CGAL_RELEASE_ID=`echo $CGAL_ZIPFILE | sed "s/.tar.gz//"`
-  echo ${CGAL_RELEASE_ID} |tee last_release_id
-  if [ ! "${CGAL_RELEASE_ID}" = "${CGAL_ZIPFILE}" ]; then
+  CGAL_RELEASE_ID="${CGAL_ZIPFILE%.tar.gz}"
+  echo "$CGAL_RELEASE_ID" | tee last_release_id
+  if [ "$CGAL_RELEASE_ID" != "$CGAL_ZIPFILE" ]; then
     USE_TARGZ="y"
   else
-    CGAL_RELEASE_ID=`echo $CGAL_ZIPFILE | sed "s/.tar.bz2//"`
-    if [ ! "${CGAL_RELEASE_ID}" = "${CGAL_ZIPFILE}" ]; then
+    CGAL_RELEASE_ID="${CGAL_ZIPFILE%.tar.bz2}"
+    if [ "$CGAL_RELEASE_ID" != "$CGAL_ZIPFILE" ]; then
       USE_TARBZ="y"
     fi
   fi
 
-  log "${ACTUAL_LOGFILE}" "CGAL_ZIPFILE    = ${CGAL_ZIPFILE}"
-  log "${ACTUAL_LOGFILE}" "CGAL_RELEASE_ID = ${CGAL_RELEASE_ID}"
+  log "$ACTUAL_LOGFILE" "CGAL_ZIPFILE    = $CGAL_ZIPFILE"
+  log "$ACTUAL_LOGFILE" "CGAL_RELEASE_ID = $CGAL_RELEASE_ID"
 
-  log "${ACTUAL_LOGFILE}" "getting CGAL"
-  rm -f "${CGAL_ZIPFILE}"
-  if [ -n "${USE_CURL}" ]; then
-      ${CURL} ${CURL_OPTS} "${CGAL_LOCATION}" >> "${ACTUAL_LOGFILE}" 2>&1
-  else
-      ${WGET} ${WGET_OPTS} "${CGAL_LOCATION}" >> "${ACTUAL_LOGFILE}" 2>&1
-  fi
-  if [ ${?} != 0 ]; then
+  log "$ACTUAL_LOGFILE" "getting CGAL"
+  rm -f "$CGAL_ZIPFILE"
+  if ! download_file "$CGAL_LOCATION" >> "$ACTUAL_LOGFILE" 2>&1; then
     error "Could not get CGAL"
   fi
-  log_done "${ACTUAL_LOGFILE}"
+  log_done "$ACTUAL_LOGFILE"
 }
 
 
@@ -175,40 +169,39 @@ get_cgal()
 # ----------------------------------------------------------------------------------------
 unzip_cgal()
 {
-  cd "${CGAL_HOME}"
+  cd "$CGAL_HOME" || exit
 
-  log "${ACTUAL_LOGFILE}" "unzipping CGAL"
-  if [ "${USE_TARGZ}" = "y" ]; then
-    DECOMPRESSOR="${GUNZIP}"
-    log_done "${ACTUAL_LOGFILE}"
+  log "$ACTUAL_LOGFILE" "unzipping CGAL"
+  if [ "$USE_TARGZ" = "y" ]; then
+    DECOMPRESSOR="$GUNZIP"
+    log_done "$ACTUAL_LOGFILE"
   fi
 
-  if [ "${USE_TARBZ}" = "y" ]; then
+  if [ "$USE_TARBZ" = "y" ]; then
     DECOMPRESSOR="bunzip2"
   fi
 
-  log "${ACTUAL_LOGFILE}" "untarring CGAL"
-  ${DECOMPRESSOR} -c "${CGAL_ZIPFILE}" | ${TAR} xf - >> "${ACTUAL_LOGFILE}" 2>&1
-  if [ ${?} != 0 ]; then
-    error "Could not untar CGAL"
+  log "$ACTUAL_LOGFILE" "untarring CGAL"
+  if ! "$DECOMPRESSOR" -c "$CGAL_ZIPFILE" | "$TAR" xf - >> "$ACTUAL_LOGFILE" 2>&1; then
+    error "Could not extract CGAL"
   fi
 
   # check, if CGAL_DIR exists
-  if [ -d "${CGAL_HOME}/${CGAL_RELEASE_ID}" ]; then
+  if [ -d "$CGAL_HOME/$CGAL_RELEASE_ID" ]; then
     # Reset CGAL-I symlink
-    log "${ACTUAL_LOGFILE}" "Resetting CGAL-I symlink to ${CGAL_HOME}/${CGAL_RELEASE_ID}"
+    log "$ACTUAL_LOGFILE" "Resetting CGAL-I symlink to $CGAL_HOME/$CGAL_RELEASE_ID"
     rm -f CGAL-I
-    ln -s "${CGAL_HOME}/${CGAL_RELEASE_ID}" CGAL-I
+    ln -s "$CGAL_HOME/$CGAL_RELEASE_ID" CGAL-I
     # Reset CGAL-3.x-I symlink
-    CGAL_RELEASE=`echo "${CGAL_RELEASE_ID}" | sed 's/I\([^-]*\)-.*/I\1/'`
-    log "${ACTUAL_LOGFILE}" "Resetting ${CGAL_RELEASE} symlink to ${CGAL_HOME}/${CGAL_RELEASE_ID}"
-    rm -f "${CGAL_RELEASE}"
-    ln -s "${CGAL_HOME}/${CGAL_RELEASE_ID}" "${CGAL_RELEASE}"
+    CGAL_RELEASE="${CGAL_RELEASE_ID%%-*}"
+    log "$ACTUAL_LOGFILE" "Resetting $CGAL_RELEASE symlink to $CGAL_HOME/$CGAL_RELEASE_ID"
+    rm -f "$CGAL_RELEASE"
+    ln -s "$CGAL_HOME/$CGAL_RELEASE_ID" "$CGAL_RELEASE"
   else
-    error "directory ${CGAL_HOME}/${CGAL_RELEASE_ID} does not exist"
+    error "directory $CGAL_HOME/$CGAL_RELEASE_ID does not exist"
   fi
 
-  log_done "${ACTUAL_LOGFILE}"
+  log_done "$ACTUAL_LOGFILE"
 }
 
 
@@ -237,7 +230,7 @@ do
       echo "Compiled test/ directory will be kept."
       KEEP_TESTS="y"
       ;;
-      "-g")
+    "-g")
       echo "Run testsuite from GIT branch"
       export INSTALLATION_DIR="Installation/"
       export TESTSUITE_DIR="Testsuite/"
@@ -250,26 +243,37 @@ do
 done
 # Load settings
 if [ -f "${CGAL_HOME}/.autocgalrc" ]; then
+  # shellcheck source=/dev/null
   . "${CGAL_HOME}/.autocgalrc"
 else
   echo "CONFIGURATION FILE  .autocgalrc NOT FOUND" >&2;
   exit 1
 fi
 
+if [ -n "$USE_CURL" ]; then
+  download_file() {
+    "$CURL" "${CURL_OPTS[@]}" "$1"
+  }
+else
+  download_file() {
+    "$WGET" "${WGET_OPTS[@]}" "$1"
+  }
+fi
+
 LOGS_DIR="${CGAL_HOME}/AUTOTEST_LOGS"
 LOCK_FILE="${CGAL_HOME}/autotest_cgal_with_cmake.lock"
 
 # Setup logfile
-ACTUAL_LOGFILE="${CGAL_HOME}/`basename ${0}`.log"
+ACTUAL_LOGFILE="${CGAL_HOME}/$(basename "${0}").log"
 rm -f "${ACTUAL_LOGFILE}"
 
-echo "Running `basename ${0}` "'$Revision$' >> "${ACTUAL_LOGFILE}"
+echo "Running $(basename "${0}") \$Revision\$" >> "${ACTUAL_LOGFILE}"
 
-cd "$CGAL_HOME"
+cd "$CGAL_HOME" || exit
 
 # Starts the process
 
-if [ -z "${USE_LATEST_UNZIPPED}" -a -z "${SCRIPTS_DIR}" ]; then
+if [ -z "${USE_LATEST_UNZIPPED}" ] && [ -z "${SCRIPTS_DIR}" ]; then
   if [ -z "$CGAL_LOCATION" ]; then
     download_latest
     abort_if_latest_already_tested
@@ -279,59 +283,19 @@ if [ -z "${USE_LATEST_UNZIPPED}" -a -z "${SCRIPTS_DIR}" ]; then
 fi
 #reset CGAL-DIR with the updated CGAL-I
 if [ -n "${SCRIPTS_DIR}" ]; then
-  CGAL_DIR=`readlink "${CGAL_HOME}/CGAL-git"`
+  CGAL_DIR=$(readlink "${CGAL_HOME}/CGAL-git")
 else
-  CGAL_DIR=`readlink "${CGAL_HOME}/CGAL-I"`
+  CGAL_DIR=$(readlink "${CGAL_HOME}/CGAL-I")
 fi
 
 CGAL_DIR=$(echo "$CGAL_DIR" | sed -E 's/\/cygdrive\/([a-z])\//\U\1:\//')
 
 CGAL_RELEASE_ID=$(cat last_release_id)
 for HOST in ${BUILD_HOSTS}; do
-  if [ "$HOST" != "localhost" ]; then
-    #launch docker container
-    echo "export SHOW_PROGRESS=$SHOW_PROGRESS"> env.sh
-    echo "export KEEP_TESTS=$KEEP_TESTS">> env.sh
-    echo "export DO_NOT_UPLOAD=$DO_NOT_UPLOAD">> env.sh
-    echo "export DO_NOT_TEST=$DO_NOT_TEST">> env.sh
-    echo "export SCP=$SCP">> env.sh
-    echo "export WGET=$WGET">> env.sh
-    echo "export WGET_OPTS=\"$WGET_OPTS\"">> env.sh
-    echo "export CURL=$CURL">> env.sh
-    echo "export CURL_OPTS=\"$CURL_OPTS\"">> env.sh
-    echo "export CGAL_URL=$CGAL_URL">> env.sh
-    echo "export UPLOAD_RESULT_DESTINATION=$UPLOAD_RESULT_DESTINATION">> env.sh
-    echo "export LATEST_LOCATION=$LATEST_LOCATION">> env.sh
-    echo "export TAR=$TAR">> env.sh
-    echo "export GUNZIP=$GUNZIP">> env.sh
-    echo "export COMPRESSOR=$COMPRESSOR">> env.sh
-    echo "export CONSOLE_OUTPUT=$CONSOLE_OUTPUT">> env.sh
-    echo "export CGAL_HOME=/cgal_root">> env.sh
-    echo "export USE_TARGZ=$USE_TARGZ">> env.sh
-    echo "export USE_TARBZ=$USE_TARBZ">> env.sh
-    echo "export CGAL_RELEASE=$CGAL_RELEASE">> env.sh
-    echo "export LOGS_DIR=/cgal_root/AUTOTEST_LOGS">> env.sh
-    echo "export LOCK_FILE=/cgal_root/autotest_cgal_with_cmake.lock">> env.sh
-    echo "export ACTUAL_LOGFILE=/cgal_root/\`basename \${0}\`.log">> env.sh
-    echo "export REFERENCE_PLATFORMS_DIR=$REFERENCE_PLATFORMS_DIR">>env.sh
-    echo "export INSTALLATION_DIR=$INSTALLATION_DIR">>env.sh
-    echo "export TESTSUITE_DIR=$TESTSUITE_DIR">>env.sh
-    echo "export SCRIPTS_DIR=$SCRIPTS_DIR">>env.sh
-
-    docker pull cgal/testsuite-docker:debian-stable-cross-compilation-for-arm
-    if [ -z "${SCRIPTS_DIR}" ]; then #if not from branch
-      echo "export CGAL_DIR=/cgal_root/\${CGAL_LAST}">>env.sh
-      docker run --rm  -t -e CGAL_LAST="${CGAL_RELEASE_ID}" -e HOST="${HOST}" -v ${CGAL_HOME}/ssh:/tmp_ssh -v ${DEPS_DIR}:/deps -v ${CGAL_HOME}:/cgal_root cgal/testsuite-docker:debian-stable-cross-compilation-for-arm
-    else
-      echo "export CGAL_DIR=/cgal_root/CGAL-git">>env.sh
-      docker run --rm  -t -e HOST="${HOST}" -v ${CGAL_HOME}/ssh:/tmp_ssh -v ${DEPS_DIR}:/deps -v ${CGAL_HOME}:/cgal_root -v${CGAL_DIR}:/cgal_root/CGAL-git cgal/testsuite-docker:debian-stable-cross-compilation-for-arm
-    fi
-  else
-    HOST=$HOST bash -$- ${CGAL_DIR}/${SCRIPTS_DIR}developer_scripts/run_testsuite_with_ctest
-  fi
+  HOST=$HOST bash -$- "${CGAL_DIR}/${SCRIPTS_DIR}developer_scripts/run_testsuite_with_ctest"
 done
 
-cd "${CGAL_HOME}"
+cd "${CGAL_HOME}" || exit
 if [ -e "LATEST" ]; then
   mv LATEST RELEASE_NR
 fi

Scripts/developer_scripts/cgal_create_package_dir.py

@@ -33,7 +33,7 @@ PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - Put title of project here"
 descrstring = \
 r"""// PRETTY PACKAGE NAME should equal the project title in Doxyfile.in
 
-/// \defgroup PkgPACKAGERef PRETTY PACKAGE NAME Reference
+/// \defgroup PkgPACKAGERef Reference Manual
 /// \defgroup PkgPACKAGEConcepts Concepts
 /// \ingroup PkgPACKAGERef
 
@@ -47,6 +47,7 @@ r"""// PRETTY PACKAGE NAME should equal the project title in Doxyfile.in
 /// \ingroup PkgPACKAGERef
 
 /*!
+\addtogroup PkgPACKAGERef
 \cgalPkgDescriptionBegin{PACKAGE NAME,PkgPACKAGE}
 \cgalPkgPicture{pkg-small.png}
 

Scripts/developer_scripts/log.sh

@@ -5,11 +5,13 @@ log()
   LOGFILE=${1}
   shift
   if [ -n "${CONSOLE_OUTPUT}" ]; then
-      printf "${*} ...\n"
+      printf "%s ...\n" "${*}"
   fi
-  printf "\n-------------------------------------------------------\n" >> "${LOGFILE}"
-  printf "  ${*} ...\n"                                                >> "${LOGFILE}"
-  printf "\n-------------------------------------------------------\n" >> "${LOGFILE}"
+  {
+    printf "\n-------------------------------------------------------\n"
+    printf "  %s ...\n" "$*"
+    printf "\n-------------------------------------------------------\n"
+  } >> "${LOGFILE}"
 }
 
 log_done()
@@ -18,8 +20,10 @@ log_done()
       printf \
       " done\n-------------------------------------------------------\n"
   fi
-  printf "\n-------------------------------------------------------\n" >> "${1}"
-  printf "  **DONE**\n"                                                >> "${1}"
-  printf "\n-------------------------------------------------------\n" >> "${1}"
+  {
+    printf "\n-------------------------------------------------------\n"
+    printf "  **DONE**\n"
+    printf "\n-------------------------------------------------------\n"
+  } >> "${1}"
 }
 

Scripts/developer_scripts/prepare_GF_Linux_test_machine.sh

@@ -0,0 +1,332 @@
+#!/bin/bash
+set -o errexit -o nounset -o pipefail
+
+# Color output setup
+if [ -t 1 ]; then
+  COLOR_BOLD="\033[1m"
+  COLOR_GREEN="\033[32m"
+  COLOR_RESET="\033[0m"
+else
+  COLOR_BOLD=""
+  COLOR_GREEN=""
+  COLOR_RESET=""
+fi
+
+color_echo() {
+  # Print with color unless line starts with two spaces
+  if [[ "$1" =~ ^\ \  ]]; then
+    echo "$1"
+  else
+    echo -e "${COLOR_BOLD}${COLOR_GREEN}$1${COLOR_RESET}"
+  fi
+}
+
+color_printf() {
+  # Print with color unless first arg starts with two spaces
+  local fmt="$1"
+  if [[ "$fmt" =~ ^\ \  ]]; then
+    printf "$@"
+  else
+    echo -e "${COLOR_BOLD}${COLOR_GREEN}"
+    printf "$@"
+    echo -e "${COLOR_RESET}"
+  fi
+}
+
+print_command() {
+  if [ ! -t 0 ]; then
+    while IFS= read -r line; do
+      printf '  | %s\n' "$line" >&2
+    done
+  fi
+  printf '  > %s\n' "$*" >&2
+}
+
+install_packages() {
+  local packages=("$@")
+  if [ "${#packages[@]}" -eq 0 ]; then
+    return
+  fi
+  color_echo "Installing '${packages[*]}' (requires sudo privileges)..."
+  local package_manager=""
+  if command -v dnf &>/dev/null; then
+    package_manager=dnf
+  elif command -v apt &>/dev/null; then
+    package_manager=apt
+  elif command -v pacman &>/dev/null; then
+    package_manager=pacman
+  else
+    echo "Could not find a supported package manager to install '${packages[*]}'."
+    exit 1
+  fi
+  case "$package_manager" in
+  dnf)
+    $SUDO_OR_PRINT dnf install -y "${packages[@]}"
+    ;;
+  apt)
+    $SUDO_OR_PRINT apt update
+    $SUDO_OR_PRINT apt install -y "${packages[@]}"
+    ;;
+  pacman)
+    $SUDO_OR_PRINT pacman -Sy --noconfirm "${packages[@]}"
+    ;;
+  esac
+}
+
+SUDO_OR_PRINT="sudo"
+if [ "${1:-}" = "--dry-run" ]; then
+  SUDO_OR_PRINT=print_command
+  echo "Running in dry-run mode. No changes will be made."
+fi
+
+# Ensure gh CLI and jq are installed
+required_pkgs=()
+for pkg in gh jq; do
+  command -v "$pkg" &>/dev/null || required_pkgs+=("$pkg")
+done
+install_packages "${required_pkgs[@]}"
+
+if ! gh auth status &>/dev/null; then
+  echo "GitHub CLI is not authenticated. Attempting to log in..."
+  gh auth login || {
+    echo "Failed to authenticate with GitHub CLI."
+    exit 1
+  }
+fi
+
+# Fetch members and real names using GraphQL
+GF_GRAPHQL_QUERY='
+query {
+  organization(login: "CGAL") {
+    team(slug: "GeometryFactory") {
+      members(first: 100) {
+        edges {
+          node {
+            login
+            name
+            publicKeys(first: 100) {
+              edges {
+                node {
+                  id
+                  key
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}'
+
+# Fetch team members and their names from GitHub GraphQL API
+GRAPH_QL_RESULT=$(gh api graphql -f query="$GF_GRAPHQL_QUERY" --jq '.data.organization.team.members.edges.[].node')
+if [ -z "$GRAPH_QL_RESULT" ]; then
+  echo "Error: No members found in the GeometryFactory team." >&2
+  exit 1
+fi
+
+GF_MEMBERS=()
+declare -A GF_REAL_NAMES=()
+declare -A GF_SSH_KEYS=()
+
+# Parse the JSON result for logins, and names
+while IFS=$'\t' read -r login name; do
+  GF_MEMBERS+=("$login")
+  GF_REAL_NAMES["$login"]="$name"
+done < <(
+  jq -r '[ .login, .name ] | @tsv' <<<"$GRAPH_QL_RESULT"
+)
+
+# Parse the SSH keys and associate them with the respective members
+for login in "${GF_MEMBERS[@]}"; do
+  keys=$(jq -r --arg login "$login" 'select(.login == $login) | (.publicKeys.edges[].node.key // empty)' <<<"$GRAPH_QL_RESULT")
+  GF_SSH_KEYS["$login"]=""
+  while IFS=$'\n' read -r key; do
+    [[ -z "$key" ]] && continue
+    GF_SSH_KEYS["$login"]+="$key"$'\n'
+  done <<<"$keys"
+done
+
+# Mapping from GitHub login to local username (if different)
+declare -A GF_USERNAMES=(
+  ["janetournois"]="jtournois"
+  ["LeoValque"]="lvalque"
+  ["MaelRL"]="mrouxell"
+  ["SaillantNicolas"]="nsaillant"
+)
+
+# Correcting the real names for specific users
+GF_REAL_NAMES["LeoValque"]="Léo Valque"
+GF_REAL_NAMES["MaelRL"]="Maël Rouxel-Labbé"
+GF_REAL_NAMES["sloriot"]="Sébastien Loriot"
+
+# Mapping from GitHub login to extra groups (if any)
+declare -A GF_GROUPS=(
+  ["lrineau"]="wheel,docker"
+  ["SaillantNicolas"]="wheel,docker"
+  ["sloriot"]="wheel,docker"
+)
+
+color_echo "Members of the geometryfactory team:"
+for m in "${GF_MEMBERS[@]}"; do
+  keys="${GF_SSH_KEYS[$m]}"
+  nb_of_keys=$(printf '%s' "$keys" | wc -l)
+  color_printf "  %s (%s) has %d ssh keys in Github\n" "$m" "${GF_REAL_NAMES[$m]:-$m}" "$nb_of_keys"
+done
+
+# Ensure groups exists
+for group in geometryfactory docker; do
+  if ! getent group "$group" >/dev/null; then
+    $SUDO_OR_PRINT groupadd "$group"
+  fi
+done
+
+for member in "${GF_MEMBERS[@]}"; do
+  user="${GF_USERNAMES[$member]:-$member}"
+  groups="geometryfactory"
+  if [[ -n "${GF_GROUPS[$member]:-}" ]]; then
+    groups="geometryfactory,${GF_GROUPS[$member]}"
+  fi
+
+  if ! getent passwd "$user" >/dev/null; then
+    color_echo "Creating user $user and adding to group(s) $groups."
+    $SUDO_OR_PRINT useradd -m -s /bin/bash -c "${GF_REAL_NAMES[$member]:-$user}" "$user" -G "$groups"
+  else
+    color_echo "User $user already exists, adding to group(s) $groups."
+    $SUDO_OR_PRINT usermod -aG "$groups" -c "${GF_REAL_NAMES[$member]:-$user}" "$user"
+  fi
+
+  $SUDO_OR_PRINT chmod o+rx "/home/$user"
+
+  $SUDO_OR_PRINT mkdir -p "/home/$user/.ssh"
+  $SUDO_OR_PRINT chown "$user:$user" "/home/$user/.ssh"
+  $SUDO_OR_PRINT chmod 700 "/home/$user/.ssh"
+
+  # Add SSH keys from GraphQL
+  color_echo "  Adding SSH keys for user $member from Github."
+  count=0
+  auth_keys_file="/home/$user/.ssh/authorized_keys"
+  if ! sudo test -f "$auth_keys_file"; then
+    $SUDO_OR_PRINT install -m 600 -o "$user" -g "$user" /dev/null "$auth_keys_file"
+  fi
+  if [[ -n "${GF_SSH_KEYS[$member]:-}" ]]; then
+    while IFS=$'\n' read -r key; do
+      [[ -z "$key" ]] && continue
+      if ! $SUDO_OR_PRINT grep -qF -- "$key" "$auth_keys_file" </dev/null; then
+        if [ "$SUDO_OR_PRINT" = "sudo" ]; then
+          echo "$key" | sudo tee -a "$auth_keys_file" >/dev/null
+        fi
+        count=$((count + 1))
+      fi
+    done <<<"${GF_SSH_KEYS[$member]}"
+  fi
+  color_echo "  Added $count SSH keys for user $user."
+  key_count=$(sudo bash -c "[ -f '$auth_keys_file' ] && wc -l <'$auth_keys_file' || echo 0")
+  color_echo "  User $user has $key_count SSH keys in $auth_keys_file"
+done
+
+# Add cgaltest user if not exists, and create SSH key
+if ! getent passwd cgaltest >/dev/null; then
+  color_echo "Creating user cgaltest."
+  $SUDO_OR_PRINT useradd -m -s /bin/bash -c "CGAL Test User" cgaltest
+fi
+
+$SUDO_OR_PRINT mkdir -p /home/cgaltest/.ssh
+$SUDO_OR_PRINT chown cgaltest:cgaltest /home/cgaltest/.ssh
+$SUDO_OR_PRINT chmod 700 /home/cgaltest/.ssh
+$SUDO_OR_PRINT usermod -aG docker cgaltest
+$SUDO_OR_PRINT loginctl enable-linger cgaltest
+
+keyfile="/home/cgaltest/.ssh/id_ed25519"
+if ! $SUDO_OR_PRINT test -f "$keyfile"; then
+  color_echo "Generating SSH key for cgaltest."
+  if [ "$SUDO_OR_PRINT" = "sudo" ]; then
+    sudo -u cgaltest ssh-keygen -t ed25519 -N "" -f "$keyfile"
+  else
+    ssh-keygen -t ed25519 -N "" -f "$keyfile"
+  fi
+else
+  color_echo "SSH key for cgaltest already exists."
+  $SUDO_OR_PRINT cat "$keyfile.pub"
+fi
+
+color_echo "All users have been processed."
+
+color_echo "Remove users not in the GeometryFactory team."
+current_members=$(getent group geometryfactory | awk -F: '{print $4}' | tr ',' ' ')
+for user in $current_members; do
+  # Map local usernames to GitHub logins if needed
+  login="$user"
+  for k in "${!GF_USERNAMES[@]}"; do
+    if [[ "${GF_USERNAMES[$k]}" == "$user" ]]; then
+      login="$k"
+      break
+    fi
+  done
+  found=false
+  for m in "${GF_MEMBERS[@]}"; do
+    if [[ "$login" == "$m" ]]; then
+      found=true
+      break
+    fi
+  done
+  if ! $found; then
+    color_echo "  Removing user $user but keep its home directory."
+    read -p "  Are you sure you want to remove user $user? [y/N] " confirm
+    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
+      color_echo "  Skipping removal of user $user."
+      continue
+    fi
+    $SUDO_OR_PRINT userdel -f "$user"
+  fi
+done
+
+# Optionally install bat, strace, and podman-docker if not present
+need_install=()
+for cmd in bat strace python3-docker python3-pyxdg python3-sdnotify; do
+  command -v "$cmd" &>/dev/null || need_install+=("$cmd")
+done
+
+# Check if docker is missing or not emulated by podman
+need_podman_docker=false
+if ! command -v docker &>/dev/null; then
+  need_podman_docker=true
+elif docker --version 2>&1 | grep -q "podman"; then
+  need_podman_docker=true
+fi
+
+if $need_podman_docker; then
+  if [[ ! " ${need_install[*]} " =~ " podman-docker " ]]; then
+    need_install+=("podman-docker")
+  fi
+fi
+
+install_packages "${need_install[@]}"
+
+color_echo "Update the systemd tmpfiles configuration for podman."
+
+$SUDO_OR_PRINT touch /etc/containers/nodocker
+
+$SUDO_OR_PRINT mkdir -p /etc/tmpfiles.d
+sed 's|podman 0700 root root|podman 0770 root docker|g' /usr/lib/tmpfiles.d/podman.conf |
+  $SUDO_OR_PRINT tee /etc/tmpfiles.d/podman.conf >/dev/null
+
+color_echo "Update the systemd socket configuration for podman."
+
+$SUDO_OR_PRINT mkdir -p /etc/systemd/system/podman.socket.d
+$SUDO_OR_PRINT tee /etc/systemd/system/podman.socket.d/override.conf >/dev/null <<EOF
+[Socket]
+SocketMode=0660
+SocketUser=root
+SocketGroup=docker
+SELinuxContextFromNet=true
+SELinuxContext=system_u:object_r:container_var_run_t:s0
+EOF
+
+color_echo "Reloading systemd and enabling podman.socket."
+$SUDO_OR_PRINT systemctl daemon-reload
+$SUDO_OR_PRINT systemctl enable --now podman.socket
+$SUDO_OR_PRINT systemctl restart podman.socket
+
+color_echo "All done!"

Scripts/developer_scripts/run_testsuite_with_ctest

@@ -1,13 +1,25 @@
 #!/bin/bash
 #usage : script [-c -l -n -s -k] testsuite_dir
 
+if command -v rsync >/dev/null 2>&1; then
+  rsync_scp() {
+    rsync -avz --chmod=ugo=rX "$@"
+  }
+else
+  rsync_scp() {
+    command scp "$@"
+  }
+fi
+
 ##########################
 ####   LAUNCH CTEST   ####
 ##########################
 
+# shellcheck source=/dev/null
 source "${CGAL_DIR}/${SCRIPTS_DIR}developer_scripts/log.sh"
 # Load settings
 if [ -f "${CGAL_HOME}/.autocgalrc" ]; then
+  # shellcheck source=/dev/null
   . "${CGAL_HOME}/.autocgalrc"
 else
   echo "CONFIGURATION FILE  .autocgalrc NOT FOUND" >&2;
@@ -19,7 +31,7 @@ fi
 # ----------------------------------------------------------------------------------------
 value_of()
 {
-  _value=`eval "printf '$'${1}"`
+  _value=$(eval "printf '$'${1}")
   eval "printf \"${_value}\""
 }
 
@@ -27,7 +39,7 @@ value_of()
 # produce a string containing the actual date/time
 #  (used to identify files)
 # ----------------------------------------------------------------------------------------
-datestr()
+date_str()
 {
   date +%d%m%Y%H%M
 }
@@ -70,7 +82,7 @@ collect_all_reference_platforms()
 {
   log "${ACTUAL_LOGFILE}" "Indicated to build on ALL platform folders"
   if [ -d "${REFERENCE_PLATFORMS_DIR}" ]; then
-    cd "${REFERENCE_PLATFORMS_DIR}"
+    cd "${REFERENCE_PLATFORMS_DIR}" || exit 1
     for PLATFORM in * ; do
       if [ -d "${PLATFORM}" ]; then
         add_to_platforms "${PLATFORM}"
@@ -88,7 +100,7 @@ collect_all_reference_platforms()
 collect_all_current_platforms()
 {
   PLATFORMS=""
-  cd "${1}"
+  cd "${1}" || exit 1
   for PLATFORM in * ; do
     if [ -d "${PLATFORM}" ]; then
       PLATFORMS="${PLATFORMS} ${PLATFORM}"
@@ -121,10 +133,10 @@ build_platforms_list()
 setup_dirs()
 {
   # dir for the actual release
-  if [ ! -d ${CGAL_DIR}/test ]; then
-    mkdir ${CGAL_DIR}/test
+  if [ ! -d "${CGAL_DIR}/test" ]; then
+    mkdir "${CGAL_DIR}/test"
     #give all rights so that, if it is first created by docker, it is still editable without root access by the local user.
-    chmod 777 ${CGAL_DIR}/test
+    chmod 777 "${CGAL_DIR}/test"
   fi
   CGAL_TEST_DIR=${CGAL_DIR}/test
 
@@ -142,7 +154,7 @@ setup_dirs()
 
   CGAL_RELEASE_DIR="${CGAL_DIR}"
   if [ -z "$SCRIPTS_DIR" ]; then
-    CGAL_RELEASE_ID=`basename "${CGAL_RELEASE_DIR}"`
+    CGAL_RELEASE_ID=$(basename "${CGAL_RELEASE_DIR}")
   else
     CGAL_GIT_VERSION=$(sed -n '/CGAL_VERSION /s/#define CGAL_VERSION //p'<"$CGAL_DIR/${INSTALLATION_DIR}include/CGAL/version.h" | sed -n 's/-\w*//p')
     MINIMALIST_DATE=$(date +%y%m%d)
@@ -170,8 +182,8 @@ setup_dirs()
   # directories existing in the reference release are added to $PLATFORMS
   #
   PLATFORMS=""
-  build_platforms_list "`value_of BUILD_ON_${HOST}`"
-  build_platforms_list "`value_of COMPILERS_${HOST}`"
+  build_platforms_list "$(value_of "BUILD_ON_${HOST}")"
+  build_platforms_list "$(value_of "COMPILERS_${HOST}")"
 
   if [ -n "${USE_REFERENCE_PLATFORMS}" ]; then
     collect_all_reference_platforms
@@ -207,14 +219,14 @@ put_on_web()
 {
   log "${ACTUAL_LOGFILE}" "Uploading results ${1} to $UPLOAD_RESULT_DESTINATION/$2"
 
-  "$SCP" "${1}" "$UPLOAD_RESULT_DESTINATION/$2" >> "${ACTUAL_LOGFILE}"
+  rsync_scp "${1}" "$UPLOAD_RESULT_DESTINATION/$2" >> "${ACTUAL_LOGFILE}"
 }
-
+# ----------------------------------------------------------------------------------------
 put_demos_on_web()
 {
   log "${ACTUAL_LOGFILE}" "Uploading demos ${1} to $UPLOAD_DEMOS_DESTINATION/$2"
 
-  "$SCP" "${1}" "$UPLOAD_DEMOS_DESTINATION/$2" >> "${ACTUAL_LOGFILE}"
+  rsync_scp "${1}" "$UPLOAD_DEMOS_DESTINATION/$2" >> "${ACTUAL_LOGFILE}"
 }
 
 
@@ -222,7 +234,7 @@ collect_demos_binaries()
 {
   PLATFORM=${1}
 
-  cd "${CGAL_TEST_DIR}"
+  cd "${CGAL_TEST_DIR}" || exit 1
 
   echo "COLLECT_DEMOS_BINARIES=$COLLECT_DEMOS_BINARIES"
   if [ -n "$COLLECT_DEMOS_BINARIES" ]; then
@@ -232,19 +244,19 @@ collect_demos_binaries()
     DEMOS_TEST_DIR="${CGAL_DIR}/cmake/platforms/${PLATFORM}/test"
     cp "${CGAL_DIR}/${SCRIPTS_DIR}developer_scripts/cgal_demo_copy_all_dlls_cygwin.sh" "${DEMOS_TEST_DIR}"
 
-    cd ${DEMOS_TEST_DIR}
+    cd "${DEMOS_TEST_DIR}" || exit 1
 
     for demo_dir in *_Demo; do
       echo "pushd ${demo_dir}"
-      pushd "${demo_dir}"
-      bash ${DEMOS_TEST_DIR}/cgal_demo_copy_all_dlls_cygwin.sh "${demo_dir}_with_dlls" "${CONFIG_TYPE}"
-      mv "${demo_dir}_with_dlls" ${DEMOS_TEST_DIR}
-      popd
+      pushd "${demo_dir}" || exit 1
+      bash "${DEMOS_TEST_DIR}/cgal_demo_copy_all_dlls_cygwin.sh" "${demo_dir}_with_dlls" "${CONFIG_TYPE}"
+      mv "${demo_dir}_with_dlls" "${DEMOS_TEST_DIR}"
+      popd || exit 1
     done
 
-    ${TAR} cf "demos_${CGAL_TESTER}_${PLATFORM}.tar" *_Demo_with_dlls/*;
+    ${TAR} cf "demos_${CGAL_TESTER}_${PLATFORM}.tar" ./*_Demo_with_dlls/*;
     ${COMPRESSOR} -9f "demos_${CGAL_TESTER}_${PLATFORM}.tar"
-    mv "demos_${CGAL_TESTER}_${PLATFORM}.tar.gz" ${CGAL_TEST_DIR}
+    mv "demos_${CGAL_TESTER}_${PLATFORM}.tar.gz" "${CGAL_TEST_DIR}"
   else
     echo "Don't collect demos binaries for platform $PLATFORM";
   fi
@@ -256,7 +268,7 @@ publish_results()
   #
   # collect results and put them on the web
   #
-  cd "${CGAL_TEST_DIR}"
+  cd "${CGAL_TEST_DIR}" || exit 1
 
   log "${ACTUAL_LOGFILE}.test.${PLATFORM}" "COLLECTING RESULTS ${PLATFORM}-${HOST}"
 
@@ -270,11 +282,11 @@ publish_results()
 
   ${TAR} cf "test_results-${HOST}_${PLATFORM}.tar" "results_${CGAL_TESTER}_${PLATFORM}.tar.gz" "results_${CGAL_TESTER}_${PLATFORM}.txt"
   ${COMPRESSOR} -9f "test_results-${HOST}_${PLATFORM}.tar"
-  COMPILER=`printf "%s" "$1" | tr -c '[A-Za-z0-9]./[=-=]*_\'\''\":?() ' 'x'`
+  COMPILER=$(printf "%s" "$1" | tr -c '[A-Za-z0-9]./[=-=]*_'\''":?() ' 'x')
 
-  FILENAME="${CGAL_RELEASE_ID}_${CGAL_TESTER}-test`datestr`-${COMPILER}-cmake.tar.gz"
+  FILENAME="${CGAL_RELEASE_ID}_${CGAL_TESTER}-test$(date_str)-${COMPILER}-cmake.tar.gz"
 
-  LOGFILENAME="${CGAL_RELEASE_ID}-log`datestr`-${HOST}.gz"
+  LOGFILENAME="${CGAL_RELEASE_ID}-log$(date_str)-${HOST}.gz"
   ${COMPRESSOR} -9f "${ACTUAL_LOGFILE}.test.${PLATFORM}"
   mv "${ACTUAL_LOGFILE}.test.${PLATFORM}.gz" "${LOGS_DIR}/${LOGFILENAME}"
 
@@ -296,36 +308,46 @@ run_test_on_platform()
 {
   PLATFORM=${1}
 
-  NUMBER_OF_PROCESSORS="`value_of PROCESSORS_${HOST}`"
+  NUMBER_OF_PROCESSORS=$(value_of "PROCESSORS_${HOST}")
   if [ -z "${NUMBER_OF_PROCESSORS}" ]; then
     NUMBER_OF_PROCESSORS=1
   fi
   CGAL_BINARY_DIR=${CGAL_BINARY_DIR_BASE}/${PLATFORM}
-  cd "${CGAL_BINARY_DIR}"
+  cd "${CGAL_BINARY_DIR}" || exit 1
   log "${ACTUAL_LOGFILE}.test.${PLATFORM}" "Testing on host ${HOST} and platform ${PLATFORM}"
 
   if [ -f "${CGAL_HOME}/${REFERENCE_PLATFORMS_DIR}/${PLATFORM}/setup" ]; then
+    # shellcheck source=/dev/null
     source "${CGAL_HOME}/${REFERENCE_PLATFORMS_DIR}/${PLATFORM}/setup"
   else
     INIT_FILE="${CGAL_HOME}/${REFERENCE_PLATFORMS_DIR}/${PLATFORM}.cmake"
+    if ! [ -f "${INIT_FILE}" ]; then
+      INIT_FILE=""
+    fi
   fi
   if [ ! -f "${INIT_FILE}" ]; then
     echo "error NEED A INIT FILE !"
   fi
-  cmake ${INIT_FILE:+"-C${INIT_FILE}"} -DCGAL_ENABLE_TESTING=ON -DWITH_tests=ON -DCGAL_TEST_SUITE=ON $CGAL_DIR>installation.log 2>&1
+  # cspell:disable-next-line
+  cmake ${INIT_FILE:+"-C${INIT_FILE}"} -DCGAL_ENABLE_TESTING=ON -DWITH_tests=ON -DCGAL_TEST_SUITE=ON "$CGAL_DIR" > installation.log 2>&1
   rm CMakeCache.txt
-  CMAKE_OPTS="-DCGAL_TEST_SUITE=ON -DCMAKE_VERBOSE_MAKEFILE=ON -DWITH_tests=ON"
+  CMAKE_OPTS=()
+  if [ -n "${INIT_FILE}" ]; then
+    CMAKE_OPTS+=("-C${INIT_FILE}")
+  fi
+  CMAKE_OPTS+=("-DCGAL_ENABLE_TESTING=ON" "-DCGAL_TEST_SUITE=ON" "-DCMAKE_VERBOSE_MAKEFILE=ON" "-DWITH_tests=ON")
   if [ -n "${SCRIPTS_DIR}" ]; then
-    CMAKE_OPTS="${CMAKE_OPTS} -DWITH_examples=ON -DWITH_demos=ON"
+    CMAKE_OPTS+=("-DWITH_examples=ON" "-DWITH_demos=ON")
   fi
   if [ -z "${SHOW_PROGRESS}" ]; then
-    cmake ${INIT_FILE:+"-C${INIT_FILE}"} -DCGAL_ENABLE_TESTING=ON ${CMAKE_OPTS} $CGAL_DIR  >package_installation.log 2>&1
+    cmake "${CMAKE_OPTS[@]}" "$CGAL_DIR" > package_installation.log 2>&1
   else
-    cmake ${INIT_FILE:+"-C${INIT_FILE}"} -DCGAL_ENABLE_TESTING=ON ${CMAKE_OPTS} $CGAL_DIR 2>&1 |tee package_installation.log
+    cmake "${CMAKE_OPTS[@]}" "$CGAL_DIR" 2>&1 | tee package_installation.log
   fi
   LIST_TEST_FILE="${CGAL_HOME}/list_test_packages"
-  if [ -f ${LIST_TEST_FILE} ]; then
-    LIST_TEST_PACKAGES=$(source ${LIST_TEST_FILE})
+  if [ -f "${LIST_TEST_FILE}" ]; then
+    # shellcheck source=/dev/null
+    LIST_TEST_PACKAGES=$(source "${LIST_TEST_FILE}")
   fi
   INIT=""
   for pkg in $LIST_TEST_PACKAGES; do
@@ -336,18 +358,27 @@ run_test_on_platform()
       TO_TEST="${TO_TEST}|$pkg"
     fi
   done
-  #unsets the limit of 1024 bits for the logs through ssh
+  #unset the limit of 1024 bits for the logs through ssh
   echo "SET(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE 1000000000)" > CTestCustom.cmake
   echo "SET(CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE 1000000000)" >> CTestCustom.cmake
 
-  CTEST_OPTS="-T Start -T Test --timeout 1200 ${DO_NOT_TEST:+-E execution___of__}"
+  # add a configuration file for the tests (required since CMake-3.32)
+  cat <<EOF > CTestConfiguration.ini
+SourceDirectory: ${CGAL_RELEASE_DIR}
+BuildDirectory: ${CGAL_BINARY_DIR}
+EOF
+
+  CTEST_OPTS=(-T Start -T Test --timeout 1200)
+  if [ -n "${DO_NOT_TEST}" ]; then
+    CTEST_OPTS+=(-E execution___of__)
+  fi
   if [ -n "$CONFIG_TYPE" ]; then
-    CTEST_OPTS="-C ${CONFIG_TYPE} ${CTEST_OPTS}"
+    CTEST_OPTS=(-C "${CONFIG_TYPE}" "${CTEST_OPTS[@]}")
   fi
   if [ -z "${SHOW_PROGRESS}" ]; then
-    ctest ${TO_TEST:+-L ${TO_TEST} } ${CTEST_OPTS} -j${NUMBER_OF_PROCESSORS} ${KEEP_TESTS:+-FC .}>tmp.txt
+    ctest ${TO_TEST:+-L "${TO_TEST}"} "${CTEST_OPTS[@]}" "-j${NUMBER_OF_PROCESSORS}" ${KEEP_TESTS:+-FC .} > tmp.txt
   else
-    ctest ${TO_TEST:+-L ${TO_TEST} } ${CTEST_OPTS} -j${NUMBER_OF_PROCESSORS} ${KEEP_TESTS:+-FC .}|tee tmp.txt
+    ctest ${TO_TEST:+-L "${TO_TEST}"} "${CTEST_OPTS[@]}" "-j${NUMBER_OF_PROCESSORS}" ${KEEP_TESTS:+-FC .} | tee tmp.txt
   fi
 
   #####################
@@ -355,29 +386,33 @@ run_test_on_platform()
   #####################
   TAG_DIR=$(awk '/^Create new tag: /{print $4F}' tmp.txt)
   rm tmp.txt
-  cd Testing/${TAG_DIR}
+  cd "Testing/${TAG_DIR}" || exit 1
   RESULT_FILE=./"results_${CGAL_TESTER}_${PLATFORM}.txt"
   rm -f "$RESULT_FILE"
   touch "$RESULT_FILE"
-  if [ -z "${SCRIPTS_DIR}" ]; then
-    sed -n '/CGAL_VERSION /s/#define //p' < "$CGAL_DIR/${INSTALLATION_DIR}include/CGAL/version.h" >> "$RESULT_FILE"
-  else
-    echo "CGAL_VERSION ${CGAL_GIT_VERSION}">> "$RESULT_FILE"
-  fi
-  sed -n '/The CXX compiler/s/-- The CXX compiler identification is/COMPILER_VERSION =/p' < "${CGAL_BINARY_DIR}/installation.log" |sed -E "s/ = (.*)/\ = '\1\'/">> "$RESULT_FILE"
-if [ -n "${CGAL_SUMMARY_NAME}" ]; then
-  echo "CGAL_SUMMARY_NAME ${CGAL_SUMMARY_NAME}" >> "$RESULT_FILE"
-fi
-  echo "TESTER ${CGAL_TESTER}" >> "$RESULT_FILE"
-  echo "TESTER_NAME ${CGAL_TESTER}" >> "$RESULT_FILE"
-  echo "TESTER_ADDRESS ${TESTER_ADDRESS}" >> "$RESULT_FILE"
-  echo "CGAL_TEST_PLATFORM ${PLATFORM}" >> "$RESULT_FILE"
-  grep -e "^-- Operating system: " "${CGAL_BINARY_DIR}/installation.log" >> "$RESULT_FILE"
-  grep -e "^-- USING " "${CGAL_BINARY_DIR}/installation.log"|sort -u >> $RESULT_FILE
-  #Use sed to get the content of DEBUG or RELEASE CXX FLAGS so that Multiconfiguration platforms do provide their CXXXFLAGS to the testsuite page (that greps USING CXXFLAGS to get info)
-  sed -i -E 's/(^-- USING )(DEBUG|RELEASE) (CXXFLAGS)/\1\3/' $RESULT_FILE
-  sed -n '/^-- Third-party library /p' "${CGAL_BINARY_DIR}/installation.log" >> $RESULT_FILE
-  echo "------------" >> "$RESULT_FILE"
+  {
+    if [ -z "${SCRIPTS_DIR}" ]; then
+      sed -n '/CGAL_VERSION /s/#define //p' < "$CGAL_DIR/${INSTALLATION_DIR}include/CGAL/version.h"
+    else
+      echo "CGAL_VERSION ${CGAL_GIT_VERSION}"
+    fi
+    sed -n '/The CXX compiler/s/-- The CXX compiler identification is/COMPILER_VERSION =/p' < "${CGAL_BINARY_DIR}/installation.log" |sed -E "s/ = (.*)/\ = '\1\'/"
+    if [ -n "${CGAL_SUMMARY_NAME}" ]; then
+      echo "CGAL_SUMMARY_NAME ${CGAL_SUMMARY_NAME}"
+    fi
+    echo "TESTER ${CGAL_TESTER}"
+    echo "TESTER_NAME ${CGAL_TESTER}"
+    echo "TESTER_ADDRESS ${TESTER_ADDRESS}"
+    echo "CGAL_TEST_PLATFORM ${PLATFORM}"
+    grep -e "^-- Operating system: " "${CGAL_BINARY_DIR}/installation.log"
+    grep -e "^-- USING " "${CGAL_BINARY_DIR}/installation.log"|sort -u
+  } >> "$RESULT_FILE"
+  #Use sed to get the content of DEBUG or RELEASE CXX FLAGS so that multi-configuration platforms do provide their CXXFLAGS to the testsuite page (that greps USING CXXFLAGS to get info)
+  sed -i -E 's/(^-- USING )(DEBUG|RELEASE) (CXXFLAGS)/\1\3/' "$RESULT_FILE"
+  {
+    sed -n '/^-- Third-party library /p' "${CGAL_BINARY_DIR}/installation.log"
+    echo "------------"
+  } >> "$RESULT_FILE"
   #if git branch, create empty scm file for python script
   if [ -n "${SCRIPTS_DIR}" ]; then
     touch ../../../../../.scm-branch
@@ -386,10 +421,11 @@ fi
   # python3: can't open file '/cygdrive/c/CGAL_ROOT/CGAL-5.5-Ic-68/C:/CGAL_ROOT/CGAL-5.5-Ic-68/test/parse-ctest-dashboard-xml.py': [Errno 2] No such file or directory
   # It seems Python 3.9 from Cygwin cannot understand the Windows paths,
   # but its `open` function can.
-  python3 -c "exec(open(\"${CGAL_DIR}/${TESTSUITE_DIR}test/parse-ctest-dashboard-xml.py\").read())" $CGAL_TESTER $PLATFORM
+  python3 -c "exec(open(\"${CGAL_DIR}/${TESTSUITE_DIR}test/parse-ctest-dashboard-xml.py\").read())" "$CGAL_TESTER" "$PLATFORM"
 
-  for file in $(ls|grep _Tests); do
-    mv $file "$(echo "$file" | sed 's/_Tests//g')"
+  for file in *_Tests; do
+    [ -e "$file" ] || continue
+    mv -- "$file" "${file//_Tests/}"
   done
   OUTPUT_FILE=results_${CGAL_TESTER}_${PLATFORM}.tar
   TEST_REPORT="TestReport_${CGAL_TESTER}_${PLATFORM}"
@@ -398,14 +434,14 @@ fi
   cat "${CGAL_BINARY_DIR}/package_installation.log" >> "Installation/${TEST_REPORT}"
 
   #call the python script to complete the results report.
-  python3 -c "exec(open(\"${CGAL_DIR}/${TESTSUITE_DIR}test/post_process_ctest_results.py\").read())" Installation/${TEST_REPORT} ${TEST_REPORT} results_${CGAL_TESTER}_${PLATFORM}.txt
-  rm -f $OUTPUT_FILE $OUTPUT_FILE.gz
+  python3 -c "exec(open(\"${CGAL_DIR}/${TESTSUITE_DIR}test/post_process_ctest_results.py\").read())" "Installation/${TEST_REPORT}" "${TEST_REPORT}" "results_${CGAL_TESTER}_${PLATFORM}.txt"
+  rm -f "$OUTPUT_FILE" "$OUTPUT_FILE.gz"
   if [ -n "${SCRIPTS_DIR}" ]; then
     rm ../../../../../.scm-branch
   fi
-  tar cf $OUTPUT_FILE results_${CGAL_TESTER}_${PLATFORM}.txt */"$TEST_REPORT"
+  tar cf "$OUTPUT_FILE" "results_${CGAL_TESTER}_${PLATFORM}.txt" ./*/"$TEST_REPORT"
   echo
-  gzip -9f $OUTPUT_FILE
+  gzip -9f "$OUTPUT_FILE"
   cp "${OUTPUT_FILE}.gz" "results_${CGAL_TESTER}_${PLATFORM}.txt" "${CGAL_TEST_DIR}"
 }
 # ----------------------------------------------------------------------------------------
@@ -413,7 +449,7 @@ fi
 # ----------------------------------------------------------------------------------------
 run_test_on_host()
 {
-  PLATFORMS=`value_of COMPILERS_${HOST}`
+  PLATFORMS=$(value_of "COMPILERS_${HOST}")
   if [ "${PLATFORMS}" = "all" ]; then
     collect_all_current_platforms "${CGAL_BINARY_DIR_BASE}"
   fi
@@ -431,7 +467,7 @@ run_test_on_host()
     publish_results "${PLATFORM}"
 
     if [ -z "${KEEP_TESTS}" ]; then
-      rm -rf $CGAL_DIR/cmake/platforms/${PLATFORM}
+      rm -rf "$CGAL_DIR/cmake/platforms/${PLATFORM}"
     fi
   done
 }