diff --git a/Arrangement_on_surface_2/test/Arrangement_on_surface_2/cgal_test.cmake b/Arrangement_on_surface_2/test/Arrangement_on_surface_2/cgal_test.cmake
index fc61895ed77..4753352d565 100644
--- a/Arrangement_on_surface_2/test/Arrangement_on_surface_2/cgal_test.cmake
+++ b/Arrangement_on_surface_2/test/Arrangement_on_surface_2/cgal_test.cmake
@@ -194,24 +194,10 @@ function(run_test_alt name datafile)
   endif()
   cgal_debug_message(STATUS "#     run_test_alt(${ARGN})")
   cgal_debug_message(STATUS "#       -> ./${name} ${datafile} ${ARGN}")
-  set(command ${name} ${datafile} ${ARGN})
   string(MAKE_C_IDENTIFIER "${name}  ${ARGV4}  ${ARGV5}" test_name)
-  add_test(NAME ${test_name} COMMAND ${command}
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  set_property(TEST "${test_name}"
-    APPEND PROPERTY DEPENDS "compilation_of__${name}")
-  if(POLICY CMP0066) # CMake 3.7 or later
-    set_tests_properties("${test_name}"
-      PROPERTIES
-      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/__exec_test_dir
-      FIXTURES_REQUIRED ${PROJECT_NAME})
-  endif()
-  cgal_debug_message(STATUS "#       .. depends on compilation_of__${name}")
-
-#  message("   successful execution of ${name}  ${ARGV4} ${ARGV5}")
-  set_property(TEST "${test_name}"
-    APPEND PROPERTY LABELS "${PROJECT_NAME}")
-  cgal_debug_message(STATUS "add test \"${test_name}\": ${name} ${datafile} ${ARGN}")
+  cgal_add_test(${name}
+    TEST_NAME ${test_name}
+    ARGUMENTS ${datafile} ${ARGN})
 endfunction()
 
 function(run_trapped_test name datafile)
diff --git a/Installation/cmake/modules/CGAL_SetupCGALDependencies.cmake b/Installation/cmake/modules/CGAL_SetupCGALDependencies.cmake
index 9171c8a813d..776e34aac53 100644
--- a/Installation/cmake/modules/CGAL_SetupCGALDependencies.cmake
+++ b/Installation/cmake/modules/CGAL_SetupCGALDependencies.cmake
@@ -84,7 +84,9 @@ function(CGAL_setup_CGAL_dependencies target)
   else()
     set(keyword PUBLIC)
   endif()
-  if(NOT CGAL_DISABLE_GMP)
+  if(CGAL_DISABLE_GMP)
+    target_compile_definitions(${target} ${keyword} CGAL_DISABLE_GMP=1)    
+  else()
     use_CGAL_GMP_support(${target} ${keyword})
     set(CGAL_USE_GMP  TRUE CACHE INTERNAL "CGAL library is configured to use GMP")
     set(CGAL_USE_MPFR TRUE CACHE INTERNAL "CGAL library is configured to use MPFR")
diff --git a/Installation/cmake/modules/CGAL_SetupCGAL_Qt5Dependencies.cmake b/Installation/cmake/modules/CGAL_SetupCGAL_Qt5Dependencies.cmake
index 804fff7b519..dae96c444e6 100644
--- a/Installation/cmake/modules/CGAL_SetupCGAL_Qt5Dependencies.cmake
+++ b/Installation/cmake/modules/CGAL_SetupCGAL_Qt5Dependencies.cmake
@@ -52,7 +52,7 @@ if(NOT CGAL_Qt5_MISSING_DEPS)
 
   include(${CMAKE_CURRENT_LIST_DIR}/CGAL_Qt5_moc_and_resource_files.cmake)
 
-  if(CGAL_HEADER_ONLY AND (WITH_demos OR WITH_examples OR NOT CGAL_BUILDING_LIBS) AND NOT TARGET CGAL_Qt5_moc_and_resources)
+  if(CGAL_HEADER_ONLY AND (WITH_demos OR WITH_examples OR WITH_tests OR NOT CGAL_BUILDING_LIBS) AND NOT TARGET CGAL_Qt5_moc_and_resources)
     add_library(CGAL_Qt5_moc_and_resources STATIC 
       ${_CGAL_Qt5_MOC_FILES_private} 
         ${CGAL_GRAPHICSVIEW_PACKAGE_DIR}/include/CGAL/Qt/GraphicsViewNavigation.h
diff --git a/Installation/cmake/modules/CGAL_add_test.cmake b/Installation/cmake/modules/CGAL_add_test.cmake
index adf2430ff66..561dc6b0c64 100644
--- a/Installation/cmake/modules/CGAL_add_test.cmake
+++ b/Installation/cmake/modules/CGAL_add_test.cmake
@@ -40,9 +40,14 @@ if(CGAL_CTEST_DISPLAY_MEM_AND_TIME)
 endif()
 
 if(ANDROID)
-  set(ANDROID_DIR_PREFIX /data/local/tmp/)
+  set(CGAL_REMOTE_TEST_DIR_PREFIX /data/local/tmp/ CACHE PATH "Path to the directory where the tests will be executed in a remote testsuite.")
   find_program(adb_executable adb)
 endif()
+if(CGAL_RUN_TESTS_THROUGH_SSH)
+  set(CGAL_REMOTE_TEST_DIR_PREFIX /home/pi/CGAL/ CACHE PATH "Path to the directory where the tests will be executed in a remote testsuite.")
+  find_program(ssh_executable ssh)
+  find_program(scp_executable scp)
+endif()
 
 # Process a list, and replace items contains a file pattern (like
 # `*.off`) by the sublist that corresponds to the globbing of the
@@ -116,18 +121,25 @@ function(cgal_setup_test_properties test_name)
           COMMAND
           ${adb_executable} push
           ${CMAKE_CURRENT_SOURCE_DIR}
-          ${ANDROID_DIR_PREFIX}${PROJECT_NAME}
+          ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}
           )
         add_test(NAME ${PROJECT_NAME}_copy_GMP_MPFR
           COMMAND
           ${adb_executable} push
           ${GMP_LIBRARIES} ${MPFR_LIBRARIES}
-          ${ANDROID_DIR_PREFIX}${PROJECT_NAME}
+          ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}
           )
         set_property(TEST ${PROJECT_NAME}_copy_GMP_MPFR
           APPEND PROPERTY DEPENDS ${PROJECT_NAME}_SetupFixture)
         set_property(TEST ${PROJECT_NAME}_copy_GMP_MPFR
           PROPERTY FIXTURES_SETUP ${PROJECT_NAME})
+      elseif(CGAL_RUN_TESTS_THROUGH_SSH)
+        add_test(NAME ${PROJECT_NAME}_SetupFixture
+          COMMAND
+          ${scp_executable} -r
+          ${CMAKE_CURRENT_SOURCE_DIR}
+          ${SSH_HOST}:${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}
+          )
       else()
         add_test(NAME ${PROJECT_NAME}_SetupFixture
           COMMAND
@@ -143,7 +155,13 @@ function(cgal_setup_test_properties test_name)
         add_test(NAME ${PROJECT_NAME}_CleanupFixture
           COMMAND
           ${adb_executable} shell rm -rf
-          ${ANDROID_DIR_PREFIX}${PROJECT_NAME}
+          ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}
+          )
+      elseif(CGAL_RUN_TESTS_THROUGH_SSH)
+        add_test(NAME ${PROJECT_NAME}_CleanupFixture
+          COMMAND
+          ${ssh_executable} ${SSH_HOST} rm -rf
+          ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}
           )
       else()
         add_test(NAME ${PROJECT_NAME}_CleanupFixture
@@ -159,11 +177,12 @@ function(cgal_setup_test_properties test_name)
         ${PROJECT_NAME}_CleanupFixture ${PROJECT_NAME}_SetupFixture
         APPEND PROPERTY LABELS "${PROJECT_NAME}")
     endif()
-    if(NOT ANDROID)
+    if(NOT ANDROID AND NOT CGAL_RUN_TESTS_THROUGH_SSH)
       set_property(TEST "${test_name}"
         PROPERTY
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/__exec_test_dir)
     endif()
+    
     set_property(TEST "${test_name}"
       APPEND PROPERTY FIXTURES_REQUIRED "${PROJECT_NAME}")
     if(exe_name)
@@ -171,13 +190,22 @@ function(cgal_setup_test_properties test_name)
         APPEND PROPERTY FIXTURES_REQUIRED "${exe_name}")
       set_property(TEST "compilation_of__${exe_name}"
         PROPERTY FIXTURES_SETUP "${exe_name}")
-      if(ANDROID)
-        add_test(NAME "push_of__${exe_name}"
-          COMMAND ${adb_executable} push $<TARGET_FILE:${exe_name}> ${ANDROID_DIR_PREFIX}${PROJECT_NAME}/${exe_name})
+      if((ANDROID OR CGAL_RUN_TESTS_THROUGH_SSH) AND NOT TEST push_of__${exe_name})
+        if(ANDROID)
+          add_test(NAME "push_of__${exe_name}"
+            COMMAND ${adb_executable} push $<TARGET_FILE:${exe_name}> ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}/${exe_name})
+        elseif(CGAL_RUN_TESTS_THROUGH_SSH)
+          add_test(NAME "push_of__${exe_name}"
+            COMMAND ${scp_executable} $<TARGET_FILE:${exe_name}> ${SSH_HOST}:${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}/)
+        endif()
+        set_property(TEST "push_of__${exe_name}"
+          APPEND PROPERTY DEPENDS "compilation_of__${exe_name}")
         set_property(TEST "push_of__${exe_name}"
           APPEND PROPERTY FIXTURES_SETUP "${exe_name}")
         set_property(TEST "push_of__${exe_name}"
-          APPEND PROPERTY DEPENDS "compilation_of__${exe_name}")
+          APPEND PROPERTY FIXTURES_REQUIRED "${PROJECT_NAME}")
+        set_property(TEST "push_of__${exe_name}"
+          APPEND PROPERTY LABELS "${PROJECT_NAME}")
       endif()
     endif()
   endif() # end CMake 3.7 or later
@@ -204,11 +232,19 @@ function(cgal_add_test exe_name)
 #  message("Add test ${test_name}")
   set(cin_file "${CMAKE_CURRENT_SOURCE_DIR}/${exe_name}.cin")
   if(NOT ARGS AND EXISTS ${cin_file})
+    if(ANDROID OR CGAL_RUN_TESTS_THROUGH_SSH)
+      set(cmd ${exe_name})
+    else()
+      set(cmd $<TARGET_FILE:${exe_name}>)
+    endif()
     add_test(NAME ${test_name}
       COMMAND ${TIME_COMMAND} ${CMAKE_COMMAND}
-      -DCMD:STRING=$<TARGET_FILE:${exe_name}>
+      -DCMD:STRING=${cmd}
       -DCIN:STRING=${cin_file}
-      -DANDROID_DIR_PREFIX=${ANDROID_DIR_PREFIX}
+      -DCGAL_REMOTE_TEST_DIR_PREFIX=${CGAL_REMOTE_TEST_DIR_PREFIX}
+      -DSSH=${SSH}
+      -DSSH_HOST=${SSH_HOST}
+      -DCGAL_REMOTE_TEST_DIR_PREFIX=${CGAL_REMOTE_TEST_DIR_PREFIX}
       -DPROJECT_NAME=${PROJECT_NAME}
       -P "${CGAL_MODULES_DIR}/run_test_with_cin.cmake")
     set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
@@ -241,34 +277,15 @@ function(cgal_add_test exe_name)
     endif()
     #	message(STATUS "add test: ${exe_name} ${ARGS}")
     if(ANDROID)
-      add_test(NAME ${test_name} COMMAND ${TIME_COMMAND} ${adb_executable} shell cd ${ANDROID_DIR_PREFIX}${PROJECT_NAME} && LD_LIBRARY_PATH=${ANDROID_DIR_PREFIX}${PROJECT_NAME} ${ANDROID_DIR_PREFIX}${PROJECT_NAME}/${exe_name} ${ARGS})
+      add_test(NAME ${test_name} COMMAND ${TIME_COMMAND} ${adb_executable} shell cd ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME} && LD_LIBRARY_PATH=${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME} ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}/${exe_name} ${ARGS})
+    elseif(CGAL_RUN_TESTS_THROUGH_SSH)
+      STRING(REPLACE ";" " " arg_str "${ARGS}")
+      add_test(NAME ${test_name} COMMAND bash -c "${TIME_COMMAND} ${ssh_executable}  ${SSH_HOST} \"cd ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME} && ${CGAL_REMOTE_TEST_DIR_PREFIX}${PROJECT_NAME}/${exe_name} ${arg_str} 3< <(cat; kill -INT 0)\" <&1")
     else()
       add_test(NAME ${test_name} COMMAND ${TIME_COMMAND} $<TARGET_FILE:${exe_name}> ${ARGS})
     endif()
   endif()
   cgal_setup_test_properties(${test_name} ${exe_name})
-  return()
-
-  if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${exe_name}.cin")
-    set(ARGS "${CMAKE_CURRENT_SOURCE_DIR}/${exe_name}.cin")
-  elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${ARGV2}.cmd")
-    file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/${ARGV2}.cmd"
-      ARGS LIMIT_COUNT 1)
-  elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${ARGV1}.cmd")
-    file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/${ARGV1}.cmd"
-      ARGS LIMIT_COUNT 1)
-  elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${exe_name}.cmd")
-    file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/${exe_name}.cmd"
-      ARGS LIMIT_COUNT 1)
-    # TODO: handle multi-lines .cmd files
-    # see https://github.com/CGAL/cgal/pull/1295/files/c65d3abe17bb3e677b8077996cdaf8672f9c4c6f#r71705451
-  endif()
-  string(REPLACE ";" " " args_str "${ARGS}")
-  add_test(NAME ${test_name}
-    COMMAND ${TIME_COMMAND} $<TARGET_FILE:${exe_name}> ${ARGS}
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  set_property(TEST "${test_name}"
-    APPEND PROPERTY LABELS "${PROJECT_NAME}")
 endfunction()
 
 function(CGAL_add_compilation_tests_for_all_targets)
diff --git a/Installation/cmake/modules/run_test_with_cin.cmake b/Installation/cmake/modules/run_test_with_cin.cmake
index 1877beb096d..65615d61c51 100644
--- a/Installation/cmake/modules/run_test_with_cin.cmake
+++ b/Installation/cmake/modules/run_test_with_cin.cmake
@@ -1,4 +1,4 @@
-if(NOT CMD OR NOT EXISTS ${CMD})
+if(NOT CMD OR (NOT ANDROID AND NOT SSH AND NOT EXISTS ${CMD}))
   message(FATAL_ERROR
     "The variable `CMD` should be defined to the test program to run!")
 endif()
@@ -10,7 +10,12 @@ endif()
 
 if(ANDROID)
   execute_process(
-    COMMAND adb shell "cd ${ANDROID_DIR_PREFIX}${PROJECT_NAME} && ${ANDROID_DIR_PREFIX}${CMD}"
+    COMMAND adb shell "cd ${ANDROID_DIR_PREFIX}${PROJECT_NAME} && ${ANDROID_DIR_PREFIX}${PROJECT_NAME}/${CMD}"
+    INPUT_FILE ${CIN}
+    RESULT_VARIABLE error_result)
+elseif(SSH)
+  execute_process(
+    COMMAND ssh ${SSH_HOST} "cd ${SSH_DIR_PREFIX}${PROJECT_NAME} && LD_LIBRARY_PATH=${SSH_DIR_PREFIX}/lib ${SSH_DIR_PREFIX}${PROJECT_NAME}/${CMD}"
     INPUT_FILE ${CIN}
     RESULT_VARIABLE error_result)
 else()
diff --git a/Scripts/developer_scripts/autotest_cgal_with_ctest b/Scripts/developer_scripts/autotest_cgal_with_ctest
new file mode 100644
index 00000000000..81163bac119
--- /dev/null
+++ b/Scripts/developer_scripts/autotest_cgal_with_ctest
@@ -0,0 +1,271 @@
+#!/bin/bash
+
+#!/bin/bash
+#usage : script [-c -l -n -s -k] testsuite_dir
+
+##########################
+####   LAUNCH CTEST   ####
+##########################
+
+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/Members/Releases"
+export UPLOAD_RESULT_DESTINATION="cgaltest@cgaltest.geometryfactory.com:incoming"
+export LATEST_LOCATION="${CGAL_URL}/LATEST"
+export TAR="tar"
+export GUNZIP="gunzip"
+export COMPRESSOR="gzip"
+export CONSOLE_OUTPUT="y"
+export CGAL_ROOT=`pwd`
+export USE_TARGZ="n"
+export USE_TARBZ="n"
+export CGAL_RELEASE=""
+export LOGS_DIR=""
+export LOCK_FILE=""
+export LIST_TEST_PACKAGES=""
+export ACTUAL_LOGFILE=""
+export CGAL_DIR=""
+USE_LATEST_UNZIPPED=""
+
+# ----------------------------------------------------------------------------------------
+# Downloads the file "LATEST" whose contents indicates which release to test
+# ----------------------------------------------------------------------------------------
+download_latest()
+{
+  if [ -r "LATEST" ]; then
+    rm -rf LATEST
+  fi
+    log "${ACTUAL_LOGFILE}" "getting LATEST"
+    if [ -n "${USE_CURL}" ]; then
+      ${CURL} ${CURL_OPTS} "${LATEST_LOCATION}" >> "${ACTUAL_LOGFILE}" 2>&1
+    else
+      ${WGET} ${WGET_OPTS} "${LATEST_LOCATION}" >> "${ACTUAL_LOGFILE}" 2>&1
+    fi
+  if [ ! -f "LATEST" ]; then
+    error "COULD NOT DOWNLOAD LATEST!"
+  fi
+}
+
+# ----------------------------------------------------------------------------------------
+# Exits the testsuite if the latest release has been already tested.
+# This is tested by comparing files LATEST and RELEASE_NR, where
+# RELEASE_NR is a copy of the previous LATEST.
+# ----------------------------------------------------------------------------------------
+abort_if_latest_already_tested()
+{
+  if [ -r "RELEASE_NR" ]; then
+    cmp LATEST RELEASE_NR >> "${ACTUAL_LOGFILE}"
+    if [ ! ${?} != 0 ]; then
+      log "${ACTUAL_LOGFILE}" "This release has already been tested."
+      rm -f "$LOCK_FILE";
+      exit 1;
+    fi
+  fi
+}
+
+
+
+# ----------------------------------------------------------------------------------------
+# get CGAL
+# ----------------------------------------------------------------------------------------
+get_cgal()
+{
+  if [ -z "$CGAL_LOCATION" ]; then
+    for i in `cat LATEST`
+    do
+      CGAL_LOCATION="${CGAL_URL}/${i}";
+      CGAL_ZIPFILE="${i}";
+    done
+  else
+    CGAL_ZIPFILE=`echo "$CGAL_LOCATION" | sed 's|.*/||'`
+  fi
+
+  CGAL_RELEASE_ID=`echo $CGAL_ZIPFILE | sed "s/.tar.gz//"`
+  echo ${CGAL_RELEASE_ID} > 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
+      USE_TARBZ="y"
+    fi
+  fi
+
+  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
+    error "Could not get CGAL"
+  fi
+  log_done "${ACTUAL_LOGFILE}"
+}
+
+
+# ----------------------------------------------------------------------------------------
+# Unzips and untars the downloaded CGAL release
+# ----------------------------------------------------------------------------------------
+unzip_cgal()
+{
+  cd "${CGAL_ROOT}"
+
+  log "${ACTUAL_LOGFILE}" "unzipping CGAL"
+  if [ "${USE_TARGZ}" = "y" ]; then
+    DECOMPRESSOR="${GUNZIP}"
+    log_done "${ACTUAL_LOGFILE}"
+  fi
+
+  if [ "${USE_TARBZ}" = "y" ]; then
+    DECOMPRESSOR="bunzip2"
+  fi
+
+  log "${ACTUAL_LOGFILE}" "untarring CGAL"
+  ${DECOMPRESSOR} -c "${CGAL_ZIPFILE}" > /dev/null
+  ${DECOMPRESSOR} -c "${CGAL_ZIPFILE}" | ${TAR} xf - >> "${ACTUAL_LOGFILE}" 2>&1
+  if [ ${?} != 0 ]; then
+    error "Could not untar CGAL"
+  fi
+
+  # check, if CGAL_DIR exists
+  if [ -d "${CGAL_ROOT}/${CGAL_RELEASE_ID}" ]; then
+    # Reset CGAL-I symlink
+    log "${ACTUAL_LOGFILE}" "Resetting CGAL-I symlink to ${CGAL_ROOT}/${CGAL_RELEASE_ID}"
+    rm -f CGAL-I
+    ln -s "${CGAL_ROOT}/${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_ROOT}/${CGAL_RELEASE_ID}"
+    rm -f "${CGAL_RELEASE}"
+    ln -s "${CGAL_ROOT}/${CGAL_RELEASE_ID}" "${CGAL_RELEASE}"
+  else
+    error "directory ${CGAL_ROOT}/${CGAL_RELEASE_ID} does not exist"
+  fi
+
+  log_done "${ACTUAL_LOGFILE}"
+}
+
+
+
+# Parse command line arguments
+for arg in "$@"
+do
+  case "$arg" in 
+    "-c")
+      echo "Using latest unzipped release instead of getting a new one from the server"
+      USE_LATEST_UNZIPPED="y"
+      ;;
+    "-l")
+      echo "Not uploading results to dashboard"
+      DO_NOT_UPLOAD="y"
+      ;;
+    "-n")
+       echo "No testsuite will be launched. Installation only."
+      DO_NOT_TEST="y"
+      ;;
+    "-s")
+      echo "Showing progress."
+      SHOW_PROGRESS="y"
+      ;;
+    "-k")
+      echo "Compiled test/ directory will be kept."
+      KEEP_TESTS="y"
+      ;;
+    *)
+      CGAL_LOCATION=$arg
+  esac
+done
+
+# Load settings
+if [ -f "$CGAL_ROOT/.autocgalrc" ]; then
+  . "$CGAL_ROOT/.autocgalrc"
+else
+  echo "CONFIGURATION FILE  .autocgalrc NOT FOUND" >&2;
+  exit 1
+fi
+
+
+CGAL_DIR=`readlink "${CGAL_ROOT}/CGAL-I"`
+source "${CGAL_DIR}/developer_scripts/log.sh"
+LOGS_DIR="${CGAL_ROOT}/AUTOTEST_LOGS"
+LOCK_FILE="${CGAL_ROOT}/autotest_cgal_with_cmake.lock"
+LIST_TEST_PACKAGES="${CGAL_ROOT}/list_test_packages"
+
+# Setup logfile
+ACTUAL_LOGFILE="${CGAL_ROOT}/`basename ${0}`.log"
+rm -f "${ACTUAL_LOGFILE}"
+
+echo "Running `basename ${0}` "'$Revision$' >> "${ACTUAL_LOGFILE}" 
+
+cd "$CGAL_ROOT"
+
+# Starts the process
+
+if [ -z "${USE_LATEST_UNZIPPED}" ]; then
+  if [ -z "$CGAL_LOCATION" ]; then
+    download_latest
+    abort_if_latest_already_tested
+  fi
+  get_cgal
+  unzip_cgal
+fi
+#reset CGAL-DIR with the updated CGAL-I
+CGAL_DIR=`readlink "${CGAL_ROOT}/CGAL-I"`
+CGAL_RELEASE_ID=$(cat last_release_id)
+
+PLATFORMS=`value_of COMPILERS_${HOST}`
+#setup dir
+setup_dirs
+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_ROOT=/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 CGAL_DIR=/cgal_root/\${CGAL_LAST}">>env.sh
+    echo "export LIST_TEST_PACKAGES=/cgal_root/list_test_packages">> 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
+    
+    docker pull cgal/testsuite-docker:debian-stable-cross-compilation-for-arm
+    docker run --rm  -t -e CGAL_LAST="${CGAL_RELEASE_ID}" -e HOST="${HOST}" -v ${CGAL_ROOT}/ssh:/tmp_ssh -v ${DEPS_DIR}:/deps -v ${CGAL_ROOT}:/cgal_root cgal/testsuite-docker:debian-stable-cross-compilation-for-arm
+  else
+    HOST=$HOST bash ${CGAL_DIR}/developer_scripts/run_testsuite_with_cmake
+  fi
+done
+
+cd "${CGAL_ROOT}"
+if [ -e "LATEST" ]; then
+  mv LATEST RELEASE_NR
+fi
diff --git a/Scripts/developer_scripts/log.sh b/Scripts/developer_scripts/log.sh
new file mode 100644
index 00000000000..05ebc8eab64
--- /dev/null
+++ b/Scripts/developer_scripts/log.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+log()
+{
+  LOGFILE=${1}
+  shift
+  if [ -n "${CONSOLE_OUTPUT}" ]; then
+      printf "${*} ...\n"
+  fi
+  printf "\n-------------------------------------------------------\n" >> "${LOGFILE}"
+  printf "  ${*} ...\n"                                                >> "${LOGFILE}"
+  printf "\n-------------------------------------------------------\n" >> "${LOGFILE}"
+}
+
+log_done()
+{
+  if [ -n "${CONSOLE_OUTPUT}" ]; then
+      printf \
+      " done\n-------------------------------------------------------\n"
+  fi
+  printf "\n-------------------------------------------------------\n" >> "${1}"
+  printf "  **DONE**\n"                                                >> "${1}"
+  printf "\n-------------------------------------------------------\n" >> "${1}"
+}
+
diff --git a/Scripts/developer_scripts/run_testsuite_with_cmake b/Scripts/developer_scripts/run_testsuite_with_cmake
new file mode 100644
index 00000000000..eefea70e264
--- /dev/null
+++ b/Scripts/developer_scripts/run_testsuite_with_cmake
@@ -0,0 +1,348 @@
+#!/bin/bash
+#usage : script [-c -l -n -s -k] testsuite_dir
+
+##########################
+####   LAUNCH CTEST   ####
+##########################
+
+source "${CGAL_DIR}/developer_scripts/log.sh"
+# Load settings
+if [ -f "$CGAL_ROOT/.autocgalrc" ]; then
+  . "$CGAL_ROOT/.autocgalrc"
+else
+  echo "CONFIGURATION FILE  .autocgalrc NOT FOUND" >&2;
+  exit 1
+fi
+
+# ----------------------------------------------------------------------------------------
+# function to print the value of variable $1
+# ----------------------------------------------------------------------------------------
+value_of()
+{
+  _value=`eval "printf '$'${1}"`
+  eval "printf \"${_value}\""
+}
+
+# ----------------------------------------------------------------------------------------
+# produce a string containing the actual date/time
+#  (used to identify files)
+# ----------------------------------------------------------------------------------------
+datestr()
+{
+  date +%d%m%Y%H%M
+}
+
+
+# ----------------------------------------------------------------------------------------
+# Return 0 if $1 exists in the list $2, otherwise returns non-zero.
+# ----------------------------------------------------------------------------------------
+is_in_list()
+{
+  ELEMENT=${1}
+  LIST=${2}
+
+  for E in ${LIST} ; do
+    if [ "${E}" = "${ELEMENT}" ] ; then
+      return 0
+    fi
+  done
+
+  return 1
+}
+
+
+# ----------------------------------------------------------------------------------------
+# Uniquely adds $1 to the global, space-separated list $PLATFORMS
+# (if it is not in the list already)
+# ----------------------------------------------------------------------------------------
+add_to_platforms()
+{
+  if ! is_in_list "${1}" "${PLATFORMS}" ; then
+    PLATFORMS="${PLATFORMS} ${1}"
+  fi
+}
+
+# ----------------------------------------------------------------------------------------
+# Uniquely adds to the global, space-separated list $PLATFORMS all the directories found
+# under ${REFERENCE_PLATFORMS_DIR}
+# ----------------------------------------------------------------------------------------
+collect_all_reference_platforms()
+{
+  log "${ACTUAL_LOGFILE}" "Indicated to build on ALL platform folders"
+  if [ -d "${REFERENCE_PLATFORMS_DIR}" ]; then
+    cd "${REFERENCE_PLATFORMS_DIR}"
+    for PLATFORM in * ; do
+      if [ -d "${PLATFORM}" ]; then
+        add_to_platforms "${PLATFORM}"
+      fi
+    done
+  else
+    log "${ACTUAL_LOGFILE}" "WARNING: Invalid reference platforms directory: ${REFERENCE_PLATFORMS_DIR}"
+  fi
+}
+
+# ----------------------------------------------------------------------------------------
+# Uniquely adds to the global, space-separated list $PLATFORMS all the directories found
+# under $1
+# ----------------------------------------------------------------------------------------
+collect_all_current_platforms()
+{
+  PLATFORMS=""
+  cd "${1}"
+  for PLATFORM in * ; do
+    if [ -d "${PLATFORM}" ]; then
+      PLATFORMS="${PLATFORMS} ${PLATFORM}"
+    fi
+  done
+}
+
+# ----------------------------------------------------------------------------------------
+# Uniquely adds to the global, space-separated list $PLATFORMS all the directory names
+# listed in the space-separated list $1
+# NOTE: If any such name is "all", it's NOT added as a platform and the flag
+# USE_REFERENCE_PLATFORMS is set instead.
+# ----------------------------------------------------------------------------------------
+build_platforms_list()
+{
+  for LOCAL_PLATFORM in $1; do
+    if [ "${LOCAL_PLATFORM}" = "all" ] ; then
+      USE_REFERENCE_PLATFORMS='y'
+    else
+      add_to_platforms "${LOCAL_PLATFORM}"
+    fi
+  done
+}
+
+
+# ----------------------------------------------------------------------------------------
+# Sets up the variables indicating the directories to use.
+# Crates all platform directories under the current release binary folder.
+# ----------------------------------------------------------------------------------------
+setup_dirs()
+{
+  # dir for the actual release
+  
+  CGAL_TEST_DIR=${CGAL_DIR}/test
+
+  if [ ! -d "${CGAL_DIR}/cmake" ]; then
+    mkdir "${CGAL_DIR}/cmake"
+    log "${ACTUAL_LOGFILE}" "Creating ${CGAL_DIR}/cmake"
+  fi
+
+  if [ ! -d "${CGAL_DIR}/cmake/platforms" ]; then
+    mkdir "${CGAL_DIR}/cmake/platforms"
+    log "${ACTUAL_LOGFILE}" "Creating ${CGAL_DIR}/cmake/platforms"
+  fi
+
+  CGAL_RELEASE_DIR="${CGAL_DIR}"
+
+  CGAL_RELEASE_ID=`basename "${CGAL_RELEASE_DIR}"`
+
+  #todo : too complicated for nothing. Take a simpler outsource build dir
+  CGAL_BINARY_DIR_BASE=${CGAL_RELEASE_DIR}/cmake/platforms
+
+  log "${ACTUAL_LOGFILE}" "Release to test ${CGAL_RELEASE_DIR}"
+  log "${ACTUAL_LOGFILE}" "CGAL_RELEASE_ID=${CGAL_RELEASE_ID}"
+
+  if [ ! -r "${LOGS_DIR}" ]; then
+    mkdir "$LOGS_DIR"
+  fi
+
+  #
+  # Collects the list of platform directories to build and test on
+  #
+  # The global variable PLATFORMS contains all the platform directories for all hosts
+  # as indicated in .autocgalrc.
+  # If .autocgalrc says "all" in any entry for BUILD_ON_* or COMPILERS_*, the platform
+  # 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}`"
+
+  if [ -n "${USE_REFERENCE_PLATFORMS}" ]; then
+    collect_all_reference_platforms
+  fi
+  
+  for PLATFORM in ${PLATFORMS}; do
+
+    CGAL_BINARY_DIR=${CGAL_BINARY_DIR_BASE}/${PLATFORM}
+
+    if [ ! -d "${CGAL_BINARY_DIR}" ]; then
+      log "${ACTUAL_LOGFILE}" "Creating platform directory ${CGAL_BINARY_DIR}"
+      mkdir "${CGAL_BINARY_DIR}"
+    fi
+
+  done
+}
+
+
+# ----------------------------------------------------------------------------------------
+# function to put result files on the web
+# $1 = source filename (full path)
+# $2 = target filename (basename only)
+# ----------------------------------------------------------------------------------------
+put_on_web()
+{
+  log "${ACTUAL_LOGFILE}" "Uploading results ${1} to $UPLOAD_RESULT_DESTINATION/$2"
+
+  "$SCP" "${1}" "$UPLOAD_RESULT_DESTINATION/$2" >> "${ACTUAL_LOGFILE}"
+}
+
+
+
+publish_results()
+{
+  PLATFORM=${1}
+  #
+  # collect results and put them on the web
+  #
+  cd "${CGAL_TEST_DIR}"
+
+  log "${ACTUAL_LOGFILE}.test.${PLATFORM}" "COLLECTING RESULTS ${PLATFORM}-${HOST}"
+
+  # If this file does not exist results collection failed. Fake a results so this fact is itself reported
+  if [ ! -f "results_${CGAL_TESTER}_${PLATFORM}.txt" ]; then
+    log "${ACTUAL_LOGFILE}.test.${PLATFORM}" "Results collection for tester ${CGAL_TESTER} and platform ${PLATFORM} failed!"
+    echo "Results collection failed!" >> "results_${CGAL_TESTER}_${PLATFORM}.txt"
+    ${TAR} cf "results_${CGAL_TESTER}_${PLATFORM}.tar" "results_${CGAL_TESTER}_${PLATFORM}.txt"
+    ${COMPRESSOR} -9f "results_${CGAL_TESTER}_${PLATFORM}.tar"
+  fi
+
+  ${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" "$2" | tr -c '[A-Za-z0-9]./[=-=]*_\'\''\":?() ' 'x'`
+  FILENAME="${CGAL_RELEASE_ID}_${CGAL_TESTER}-test`datestr`-${COMPILER}-cmake.tar.gz"
+  LOGFILENAME="${CGAL_RELEASE_ID}-log`datestr`-${HOST}.gz"
+  ${COMPRESSOR} -9f "${ACTUAL_LOGFILE}.test.${PLATFORM}"
+  mv "${ACTUAL_LOGFILE}.test.${PLATFORM}.gz" "${LOGS_DIR}/${LOGFILENAME}"
+
+  log_done "${ACTUAL_LOGFILE}.test.${PLATFORM}"
+
+  log "${ACTUAL_LOGFILE}" "Test results: ${CGAL_TEST_DIR}/test_results-${HOST}_${PLATFORM}.tar.gz"
+
+  if [ -z "${DO_NOT_UPLOAD}" ]; then
+    log "${ACTUAL_LOGFILE}.test.${PLATFORM}" "PUTTING RESULTS ON THE WEB"
+    put_on_web "test_results-${HOST}_${PLATFORM}.tar.gz" "${FILENAME}"
+    if [ -e "demos_${CGAL_TESTER}_${PLATFORM}.tar.gz" ]; then
+      put_on_web "demos_${CGAL_TESTER}_${PLATFORM}.tar.gz" "demos-${FILENAME}"
+    fi
+    log_done "${ACTUAL_LOGFILE}"
+  fi
+
+}
+run_test_on_platform()
+{
+  PLATFORM=${1}
+
+  NUMBER_OF_PROCESSORS="`value_of PROCESSORS_${HOST}`"
+  CGAL_BINARY_DIR=${CGAL_BINARY_DIR_BASE}/${PLATFORM}
+  cd "${CGAL_BINARY_DIR}"
+  log "${ACTUAL_LOGFILE}.test.${PLATFORM}" "Testing on host ${HOST} and platform ${PLATFORM}"
+  INIT_FILE="${CGAL_ROOT}/${REFERENCE_PLATFORMS_DIR}/${PLATFORM}.cmake"
+  if [ ! -f "${INIT_FILE}" ]; then
+    echo "error NEED A INIT FILE !"
+  fi
+  
+  cmake ${INIT_FILE:+"-C${INIT_FILE}"} '${CMAKE_GENERATOR}' -DBUILD_TESTING=OFF -DWITH_tests=OFF -DWITH_CGAL_Qt5=OFF -DCGAL_HEADER_ONLY=ON $CGAL_DIR > installation.log 2>&1
+  rm CMakeCache.txt
+  if [ -z "${SHOW_PROGRESS}" ]; then
+    cmake ${INIT_FILE:+"-C${INIT_FILE}"} '${CMAKE_GENERATOR}' VERBOSE=1 $CGAL_DIR >/dev/null 2>&1
+  else
+    cmake ${INIT_FILE:+"-C${INIT_FILE}"} '${CMAKE_GENERATOR}' VERBOSE=1 $CGAL_DIR
+  fi
+  LIST_TEST_FILE="${CGAL_ROOT}/list_test_packages"
+  if [ -f ${LIST_TEST_FILE} ]; then
+    LIST_TEST_PACKAGES=$(source ${LIST_TEST_FILE})
+  fi
+  TO_TEST=""
+  INIT=""
+  for pkg in $LIST_TEST_PACKAGES; do
+  if [ -z "$INIT" ]; then 
+    TO_TEST=$pkg
+    INIT="y"
+  else
+    TO_TEST="${TO_TEST}|$pkg"
+  fi
+  done
+
+  CTEST_OPTS="-T Start -T Test  -j${NUMBER_OF_PROCESSORS} ${DO_NOT_TEST:+-E execution___of__} --timeout 1200"
+  if [ -z "${SHOW_PROGRESS}" ]; then
+    ctest  ${CTEST_OPTS} ${TO_TEST:+-L ${TO_TEST} } ${KEEP_TESTS:+-FC .}> tmp.txt
+  else
+    ctest ${CTEST_OPTS} ${TO_TEST:+-L ${TO_TEST}} ${KEEP_TESTS:+-FC .}|tee tmp.txt
+  fi
+  #####################
+  ##   GET RESULTS   ##
+  #####################
+  TAG_DIR=$(awk '/^Create new tag: /{print $4F}' tmp.txt)
+  rm tmp.txt
+  cd Testing/${TAG_DIR}
+  #python $CGAL_DIR/test/parse-ctest-dashboard-xml.py $CGAL_TESTER $PLATFORM
+  RESULT_FILE=./"results_${CGAL_TESTER}_${PLATFORM}.txt"
+  rm -f "$RESULT_FILE"
+  touch "$RESULT_FILE"
+  sed -n '/CGAL_VERSION /s/#define //p' < "$CGAL_DIR/include/CGAL/version.h" >> "$RESULT_FILE"
+  echo "TESTER ${CGAL_TESTER}" >> "$RESULT_FILE"
+  echo "TESTER_NAME ${CGAL_TESTER_NAME}" >> "$RESULT_FILE"
+  echo "TESTER_ADDRESS ${TESTER_ADDRESS}" >> "$RESULT_FILE"
+  echo "CGAL_TEST_PLATFORM ${PLATFORM}" >> "$RESULT_FILE"
+  #echo "General installation log file: ${GENERAL_BUILD_LOGFILE}"  >> "$RESULT_FILE"
+  #echo "Host-specific installation log file: ../installation.log"  >> "$RESULT_FILE"
+  grep -e "^-- USING " "${CGAL_BINARY_DIR}/installation.log" >> $RESULT_FILE 
+  echo "------------" >> "$RESULT_FILE"
+  python3 ${CGAL_DIR}/test/parse-ctest-dashboard-xml.py $CGAL_TESTER $PLATFORM
+  
+  for file in $(ls|grep _Tests); do
+    mv $file "$(echo "$file" | sed 's/_Tests//g')"
+  done
+  OUTPUT_FILE=results_${CGAL_TESTER}_${PLATFORM}.tar
+  TEST_REPORT="TestReport_${CGAL_TESTER}_${PLATFORM}"
+  
+  rm -f $OUTPUT_FILE $OUTPUT_FILE.gz
+  tar cf $OUTPUT_FILE results_${CGAL_TESTER}_${PLATFORM}.txt */"$TEST_REPORT"
+  echo
+  gzip -9f $OUTPUT_FILE
+  cp "${OUTPUT_FILE}.gz" "results_${CGAL_TESTER}_${PLATFORM}.txt" "${CGAL_TEST_DIR}"
+}
+# ----------------------------------------------------------------------------------------
+# Runs the test on the host $1
+# ----------------------------------------------------------------------------------------
+run_test_on_host()
+{
+  PLATFORMS=`value_of COMPILERS_${HOST}`
+  if [ "${PLATFORMS}" = "all" ]; then
+    collect_all_current_platforms "${CGAL_BINARY_DIR_BASE}"
+  fi
+
+  for PLATFORM in ${PLATFORMS}; do
+    run_test_on_platform "${PLATFORM}"
+    publish_results "${PLATFORM}"
+  done
+}
+
+
+#setup dir
+setup_dirs
+
+
+# Setup cmake 
+if uname | grep -q "CYGWIN"; then
+  JOM="`which jom`"
+  if [ -e "$JOM" ]; then 
+    CMAKE_GENERATOR='-GNMake Makefiles JOM'
+    MAKE_CMD='jom'
+  else 
+    CMAKE_GENERATOR='-GNMake Makefiles'
+    MAKE_CMD='nmake'
+  fi
+  IS_CYGWIN='y'
+else
+  MAKE_CMD='make'
+fi
+
+log "${ACTUAL_LOGFILE}" "running the testsuites"
+if [ -n "${CONSOLE_OUTPUT}" ]; then
+    printf "\n-------------------------------------------------------\n"
+fi
+run_test_on_host
diff --git a/Testsuite/test/parse-ctest-dashboard-xml.py b/Testsuite/test/parse-ctest-dashboard-xml.py
index 2d3e8a9eab2..5e4354345de 100644
--- a/Testsuite/test/parse-ctest-dashboard-xml.py
+++ b/Testsuite/test/parse-ctest-dashboard-xml.py
@@ -2,23 +2,31 @@ from __future__ import print_function
 from collections import defaultdict
 import xml.etree.ElementTree as ET
 import os
+import io
 import errno
 import re
+import sys
+import base64
+import zlib
+import gzip
 
 result_file_name='{dir}/results_{tester}_{platform}.txt'
 result_info_file_name='{dir}/results_{tester}_{platform}.info'
 test_report_filename='{dir}/TestReport_{tester}_{platform}'
 
-xml = open("Test.xml", 'rb').read();
+xml = open("Test.xml", 'rb').read()
 
-def open_file_create_dir(filename, mode):
+def open_file_create_dir(filename, mode, *args, **kwargs):
     if not os.path.exists(os.path.dirname(filename)):
         try:
             os.makedirs(os.path.dirname(filename))
         except OSError as exc: # Guard against race condition
             if exc.errno != errno.EEXIST:
                 raise
-    return open(filename, mode)
+    if kwargs.get('gzip', None) == True:
+        return gzip.open(filename, mode)
+    else:
+        return open(filename, mode)
 
 root=ET.fromstring(xml)
 testing = root.find('Testing')
@@ -31,42 +39,35 @@ for t in testlist:
 
 tests = {}
 labels = set()
+tester_name=sys.argv[1]
+platform_name=sys.argv[2]
 for t in testing.findall('Test'):
+    t_output = t.find('Results').find('Measurement').find('Value')
+    t_output_value = t_output.text
+    if t_output_value != None:
+        if 'encoding' in t_output.attrib and t_output.attrib['encoding'] == 'base64':
+           t_output_value = base64.standard_b64decode(t_output_value)
+        if 'compression' in t_output.attrib and t_output.attrib['compression'] == 'gzip':
+           t_output_value = zlib.decompress(t_output_value).decode("utf-8")
     tests[tests_ids[t.find('FullName').text]] = \
          { \
            "Name":   t.find('Name').text, \
            "Status": t.attrib['Status'], \
-           "Output": t.find('Results').find('Measurement').find('Value').text, \
+           "Output": t_output_value, \
            "Labels": [l.text for l in t.find('Labels').findall('Label')] if t.find('Labels') is not None else ['UNKNOWN_LABEL'], \
          }
 
-print("""
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-12
-""", file=open(result_info_file_name.format(dir=os.getcwd(),
-                                            tester="me",
-                                            platform="Mon Linux"), 'w'))
-
 tests_per_label = defaultdict(list)
 for t_id in range(0, len(tests)):
     t = tests[t_id]
-    for label in t['Labels']:
+    for l in t['Labels']:
+        label = l.replace("_Tests","")
         labels.add(label)
         tests_per_label[label].append(t)
 
 with open_file_create_dir(result_file_name.format(dir=os.getcwd(),
-                                                  tester="me",
-                                                  platform="Mon Linux"), 'w') as results:
+                                                  tester=tester_name,
+                                                  platform=platform_name), 'a+') as results:
     for label, tests in tests_per_label.items():
         result_for_label='y'
         with open_file_create_dir("{}/error.txt".format(label), 'w') as error:
@@ -74,10 +75,11 @@ with open_file_create_dir(result_file_name.format(dir=os.getcwd(),
                 print("   {} {}".format("successful " if (t['Status'] == 'passed') else "ERROR:     ", t['Name']), file=error)
                 if t['Status'] != 'passed':
                     result_for_label='n'
-                elif t['Output'] != None and re.match(r'(^|[^a-zA-Z_,:-])warning', t['Output']):
-                    result_for_label='y'
+                elif t['Output'] != None and re.search(r'(^|[^a-zA-Z_,:-])warning', t['Output'], flags=re.IGNORECASE):
+                    result_for_label='w'
 
-                with open("{}/ProgramOutput.{}".format(label, t['Name']), 'w') as f:
+                with io.open("{}/ProgramOutput.{}".format(label, t['Name']), mode="w", encoding="utf-8") as f:
+                    print("{}/ProgramOutput.{}".format(label, t['Name']))
                     f.write(t['Output'] if t['Output'] != None else "")
 
 
@@ -86,15 +88,15 @@ with open_file_create_dir(result_file_name.format(dir=os.getcwd(),
 
 for label, tests in tests_per_label.items():
         with open_file_create_dir(test_report_filename.format(dir=label,
-                                                              tester="me",
-                                                              platform="Mon Linux"), 'w') as label_report:
+                                                              tester=tester_name,
+                                                              platform=platform_name), 'w') as label_report:
             print("""
 ------------------------------------------------------------------
 - Error output from platform {platform}
 ------------------------------------------------------------------
 
 {error_txt}
-"""               .format(platform="Mon Linux",
+"""               .format(platform=platform_name,
                          error_txt=open("{}/error.txt".format(label), 'r').read()), file=label_report)
             for t in tests:
                 filename="{}/ProgramOutput.{}".format(label, t['Name'])