mirror of https://github.com/CGAL/cgal
remove no longer used scripts
This commit is contained in:
Sébastien Loriot
parent
ebe9c3af98
commit
40c8d76834
|
|
@ -1,944 +0,0 @@
|
|||
#!/bin/bash
|
||||
# ----------------------------------------------------
|
||||
# ----------------------------------------------------
|
||||
# autotest_cgal: a script to automagically install and
|
||||
# test internal CGAL releases
|
||||
# ----------------------------------------------------
|
||||
# You will need
|
||||
# * GNU wget and ftp
|
||||
# * or alternatively curl
|
||||
#
|
||||
# Furthermore you have to edit .autocgalrc in order to
|
||||
# cutomize it for your environment.
|
||||
# In particular you have to change the BUILHOSTS
|
||||
# variable to contain the names of your hosts and
|
||||
# set the COMPILERS_<hostname> variables to the
|
||||
# os-compilers descriptions on which you want to run
|
||||
# the testsuite.
|
||||
# ----------------------------------------------------
|
||||
# ----------------------------------------------------
|
||||
#
|
||||
# $URL$
|
||||
# $Id$
|
||||
|
||||
#sets the umask to 022 & 0777
|
||||
umask 022
|
||||
|
||||
# Warn deprecated use of environment variables to pass on flags
|
||||
if [ -n "$TESTSUITE_CXXFLAGS" ] ; then
|
||||
echo "\$TESTSUITE_CXXFLAGS is deprecated. Please use the CMAKE variable (CMAKE|CGAL)_CXX_FLAGS instead" >&2;
|
||||
fi
|
||||
|
||||
if [ -n "$TESTSUITE_CXXFLAGS_RELEASE" ] ; then
|
||||
echo "\$TESTSUITE_CXXFLAGS_RELEASE is deprecated. Please use the CMAKE variable (CMAKE|CGAL)_CXX_FLAGS_RELEASE instead" >&2;
|
||||
fi
|
||||
|
||||
if [ -n "$TESTSUITE_CXXFLAGS_DEBUG" ] ; then
|
||||
echo "\$TESTSUITE_CXXFLAGS_DEBUG is deprecated. Please use the CMAKE variable (CMAKE|CGAL)_CXX_FLAGS_DEBUG instead" >&2;
|
||||
fi
|
||||
|
||||
if [ -n "$TESTSUITE_LDFLAGS" ] ; then
|
||||
echo "\$TESTSUITE_LDFLAGS is deprecated. Please use the CMAKE variable (CMAKE|CGAL)_(MODULE|SHARED|EXE)_LINKER_FLAGS instead" >&2;
|
||||
fi
|
||||
|
||||
if [ -n "$TESTSUITE_LDFLAGS_RELEASE" ] ; then
|
||||
echo "\$TESTSUITE_LDFLAGS_RELEASE is deprecated. Please use the CMAKE variable (CMAKE|CGAL)_(MODULE|SHARED|EXE)_LINKER_FLAGS_RELEASE instead" >&2;
|
||||
fi
|
||||
|
||||
if [ -n "$TESTSUITE_LDFLAGS_DEBUG" ] ; then
|
||||
echo "\$TESTSUITE_LDFLAGS_DEBUG is deprecated. Please use the CMAKE variable (CMAKE|CGAL)_(MODULE|SHARED|EXE)_LINKER_FLAGS_DEBUG instead" >&2;
|
||||
fi
|
||||
|
||||
# We want english warning and error messages!!
|
||||
LANG=C
|
||||
LC_ALL=C
|
||||
export LANG
|
||||
export LC_ALL
|
||||
|
||||
SCP="scp"
|
||||
WGET="wget"
|
||||
WGET_OPTS="--no-check-certificate --no-verbose"
|
||||
CURL="curl"
|
||||
CURL_OPTS="-k --remote-name --silent --location-trusted"
|
||||
CGAL_URL="https://cgal.geometryfactory.com/CGAL/Releases"
|
||||
LATEST_LOCATION="${CGAL_URL}/LATEST"
|
||||
TAR="tar"
|
||||
GZIP="gzip"
|
||||
GUNZIP="gunzip"
|
||||
COMPRESSOR="${GZIP}"
|
||||
SENDMAIL="mail"
|
||||
CGAL_TESTER=`whoami`
|
||||
CGAL_TESTER_NAME="${CGAL_TESTER}"
|
||||
CGAL_TESTER_ADDRESS="${CGAL_TESTER}"
|
||||
CONSOLE_OUTPUT="y"
|
||||
CGAL_ROOT=`pwd`
|
||||
UPLOAD_RESULT_DESTINATION="cgaltest@cgaltest.geometryfactory.com:incoming"
|
||||
BUILD_HOSTS="must_be_set_in_.autocgalrc"
|
||||
MAIL_ADDRESS="must_be_set_in_.autocgalrc"
|
||||
MYSHELL=""
|
||||
REFERENCE_PLATFORMS_DIR="must_be_set_in_.autocgalrc"
|
||||
ACTUAL_DIR=`pwd`
|
||||
RSH="rsh"
|
||||
NICE_OPTIONS="-19"
|
||||
USE_TARGZ="n"
|
||||
USE_TARBZ="n"
|
||||
PLATFORMS=""
|
||||
PLATFORM=""
|
||||
USE_REFERENCE_PLATFORMS=""
|
||||
SHOW_PROGRESS=""
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# write to logfile
|
||||
# $1 = logfile
|
||||
# ----------------------------------------------------------------------------------------
|
||||
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}"
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# produce a string containing the actual date/time
|
||||
# (used to identify files)
|
||||
# ----------------------------------------------------------------------------------------
|
||||
datestr()
|
||||
{
|
||||
date +%d%m%Y%H%M
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# Print error and exit
|
||||
# ----------------------------------------------------------------------------------------
|
||||
error()
|
||||
{
|
||||
if [ -n "${CONSOLE_OUTPUT}" ]; then
|
||||
printf "\nERROR: ${*}, 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}"
|
||||
done
|
||||
fi
|
||||
rm -rf "$LOCK_FILE";
|
||||
exit 1
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# 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
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# function to print the value of variable $1
|
||||
# ----------------------------------------------------------------------------------------
|
||||
value_of()
|
||||
{
|
||||
_value=`eval "printf '$'${1}"`
|
||||
eval "printf \"${_value}\""
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# Executes a command remotely
|
||||
# $1 = HOST
|
||||
# $2 = COMMAND
|
||||
# ----------------------------------------------------------------------------------------
|
||||
remote_command()
|
||||
{
|
||||
if [ "${1}" = "localhost" ]; then
|
||||
eval $2
|
||||
else
|
||||
printf "** Logging into host ${1} **\n"
|
||||
${RSH} ${1} ${MYSHELL} \"${2}\"
|
||||
fi
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# 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//"`
|
||||
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}" | ${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}"
|
||||
}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# 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_DIR=`readlink "${CGAL_ROOT}/CGAL-I"`
|
||||
|
||||
CGAL_TEST_DIR=${CGAL_DIR}/test
|
||||
CGAL_DATA_DIR=${CGAL_DIR}/data
|
||||
export CGAL_DATA_DIR=$(echo "$CGAL_DATA_DIR" | sed -E 's/\/cygdrive\/([a-z])\//\U\1:\//')
|
||||
|
||||
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
|
||||
|
||||
export CGAL_RELEASE_DIR="${CGAL_DIR}"
|
||||
|
||||
CGAL_RELEASE_ID=`basename "${CGAL_RELEASE_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=""
|
||||
|
||||
for HOST in ${BUILD_HOSTS}; do
|
||||
|
||||
build_platforms_list "`value_of BUILD_ON_${HOST}`"
|
||||
build_platforms_list "`value_of COMPILERS_${HOST}`"
|
||||
|
||||
done
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# copy stuff from old CGAL installation
|
||||
# ----------------------------------------------------------------------------------------
|
||||
copy_old_stuff()
|
||||
{
|
||||
if [ -d "${REFERENCE_PLATFORMS_DIR}" ]; then
|
||||
|
||||
cd "${CGAL_BINARY_DIR_BASE}"
|
||||
|
||||
for PLATFORM in * ; do
|
||||
if [ -d "${PLATFORM}" ]; then
|
||||
|
||||
# if the reference platform folder contains a setup script, copy it
|
||||
if [ -f "${REFERENCE_PLATFORMS_DIR}/${PLATFORM}/setup" ]; then
|
||||
log "${ACTUAL_LOGFILE}" "Copying reference platform setup script [${REFERENCE_PLATFORMS_DIR}/${PLATFORM}/setup] in [${CGAL_BINARY_DIR_BASE}/${PLATFORM}]"
|
||||
cp "${REFERENCE_PLATFORMS_DIR}/${PLATFORM}/setup" "${CGAL_BINARY_DIR_BASE}/${PLATFORM}"
|
||||
|
||||
# hack on Windows, where 'cp' does not copy the Windows ACLs
|
||||
chmod a+r "${CGAL_BINARY_DIR_BASE}/${PLATFORM}/setup"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
fi
|
||||
}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# Builds the CGAL library on the host specified at $1
|
||||
# ----------------------------------------------------------------------------------------
|
||||
build_cgal_on_host()
|
||||
{
|
||||
HOST=${1}
|
||||
|
||||
PLATFORMS="`value_of BUILD_ON_${HOST}`"
|
||||
|
||||
|
||||
if [ -z "${PLATFORMS}" ]; then
|
||||
PLATFORMS=`value_of COMPILERS_${HOST}`
|
||||
fi
|
||||
|
||||
if [ "${PLATFORMS}" = "all" ]; then
|
||||
collect_all_current_platforms "${CGAL_BINARY_DIR_BASE}"
|
||||
fi
|
||||
|
||||
if [ -n "${PLATFORMS}" ]; then
|
||||
|
||||
for PLATFORM in ${PLATFORMS} ; do
|
||||
|
||||
CGAL_BINARY_DIR="${CGAL_BINARY_DIR_BASE}/${PLATFORM}"
|
||||
|
||||
log "${ACTUAL_LOGFILE}" "Building cgal libs on host ${HOST} and platform ${PLATFORM}\nUnder ${CGAL_BINARY_DIR}\n"
|
||||
|
||||
if [ -f "${CGAL_BINARY_DIR}/localbuildscript" ] ; then
|
||||
log "${ACTUAL_LOGFILE}" "WARNING! Already built on platform ${PLATFORM}."
|
||||
else
|
||||
|
||||
if [ -f "${CGAL_BINARY_DIR}/setup" ]; then
|
||||
cp "${CGAL_BINARY_DIR}/setup" "${CGAL_BINARY_DIR}/localbuildscript"
|
||||
else
|
||||
rm -f "${CGAL_BINARY_DIR}/localbuildscript"
|
||||
fi
|
||||
|
||||
cat >> "${CGAL_BINARY_DIR}/localbuildscript" <<EOF
|
||||
CGAL_BINARY_DIR='${CGAL_BINARY_DIR}';
|
||||
MAKE_CMD='${MAKE_CMD}';
|
||||
|
||||
export MAKE_CMD;
|
||||
export CGAL_BINARY_DIR;
|
||||
cd '${CGAL_BINARY_DIR}';
|
||||
cmake \${INIT_FILE:+"-C\${INIT_FILE}"} -DRUNNING_CGAL_AUTO_TEST=TRUE \\
|
||||
VERBOSE=1 \\
|
||||
../../..;
|
||||
${MAKE_CMD} VERBOSE=ON -k -fMakefile ;
|
||||
cd ..;
|
||||
EOF
|
||||
if [ -z "${KEEP_TESTS}" ]; then
|
||||
cat >> "${CGAL_BINARY_DIR}/localbuildscript" <<EOF
|
||||
echo 'REMOVING COMPILATION TREE';
|
||||
rm -rf '${CGAL_BINARY_DIR}/src'
|
||||
EOF
|
||||
fi
|
||||
chmod ugo+x "${CGAL_BINARY_DIR}/localbuildscript"
|
||||
if [ -n "${SHOW_PROGRESS}" ]; then
|
||||
remote_command ${HOST} "${CGAL_BINARY_DIR}/localbuildscript" 2>&1 | tee "${ACTUAL_LOGFILE}.build.${PLATFORM}"
|
||||
else
|
||||
remote_command ${HOST} "${CGAL_BINARY_DIR}/localbuildscript" > "${ACTUAL_LOGFILE}.build.${PLATFORM}" 2>&1
|
||||
fi
|
||||
|
||||
cp "${ACTUAL_LOGFILE}.build.${PLATFORM}" "${CGAL_BINARY_DIR}/installation.log"
|
||||
fi
|
||||
|
||||
done
|
||||
else
|
||||
error "There are no platform directories under ${CGAL_BINARY_DIR_BASE} to test! "
|
||||
fi
|
||||
|
||||
}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# builds cgal
|
||||
# ----------------------------------------------------------------------------------------
|
||||
build_cgal()
|
||||
{
|
||||
for HOST in ${BUILD_HOSTS}; do
|
||||
build_cgal_on_host "${HOST}"
|
||||
done
|
||||
|
||||
# NOTE: At this point PWD is in the last platform directory where CGAL was built
|
||||
|
||||
log_done "${ACTUAL_LOGFILE}"
|
||||
cp "${ACTUAL_LOGFILE}" "${CGAL_BINARY_DIR_BASE}/installation.log"
|
||||
${COMPRESSOR} -9f "${ACTUAL_LOGFILE}"
|
||||
mv "${ACTUAL_LOGFILE}.gz" "${LOGS_DIR}/${CGAL_RELEASE_ID}-log`datestr`.gz"
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# Runs the test on the host $1 under the platform folder $2
|
||||
# the variable PROCESSORS_electra, where electra is the
|
||||
# name of the machine, is used to specify the number of
|
||||
# processors to use
|
||||
# ----------------------------------------------------------------------------------------
|
||||
run_test_on_host_and_platform()
|
||||
{
|
||||
HOST=${1}
|
||||
PLATFORM=${2}
|
||||
|
||||
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}"
|
||||
if [ "${NUMBER_OF_PROCESSORS}" = "1" ] ; then
|
||||
MAKE_OPTS=""
|
||||
else
|
||||
MAKE_OPTS="-j ${NUMBER_OF_PROCESSORS}"
|
||||
fi
|
||||
|
||||
if [ -f "${CGAL_BINARY_DIR}/localtestscript" ]; then
|
||||
log "${ACTUAL_LOGFILE}" "WARNING! Already tested on platform ${PLATFORM}."
|
||||
else
|
||||
if [ -f "${CGAL_BINARY_DIR}/setup" ]; then
|
||||
cp "${CGAL_BINARY_DIR}/setup" "${CGAL_BINARY_DIR}/localtestscript"
|
||||
else
|
||||
rm -f "${CGAL_BINARY_DIR}/localtestscript"
|
||||
fi
|
||||
|
||||
for file in "${CGAL_BINARY_DIR}/localtestscript" "${CGAL_BINARY_DIR}/localtestscript-redo-results-collection"; do
|
||||
cat >> "$file" <<EOF
|
||||
CGAL_TESTER='${CGAL_TESTER}';
|
||||
CGAL_TESTER_NAME='${CGAL_TESTER_NAME}';
|
||||
CGAL_TESTER_ADDRESS='${CGAL_TESTER_ADDRESS}';
|
||||
if [ -n "${IS_CYGWIN}" ]; then
|
||||
CGAL_DIR=\$( cygpath -w "${CGAL_BINARY_DIR}" );
|
||||
else
|
||||
CGAL_DIR='${CGAL_BINARY_DIR}';
|
||||
fi
|
||||
CGAL_TEST_HOST='${HOST}';
|
||||
CGAL_TEST_PLATFORM='${PLATFORM}';
|
||||
MAKE_CMD='${MAKE_CMD}'
|
||||
export CGAL_TESTER CGAL_TESTER_NAME CGAL_TESTER_ADDRESS;
|
||||
export CGAL_DIR;
|
||||
export CGAL_TEST_HOST CGAL_TEST_PLATFORM;
|
||||
export MAKE_CMD;
|
||||
|
||||
EOF
|
||||
done
|
||||
cat >> "${CGAL_BINARY_DIR}/localtestscript" <<EOF
|
||||
LIST_TEST_PACKAGES='${LIST_TEST_PACKAGES}'
|
||||
CGAL_ROOT='${CGAL_ROOT}'
|
||||
|
||||
rm -rf '${CGAL_BINARY_DIR}/test';
|
||||
if [ -f '${LIST_TEST_PACKAGES}' ]; then
|
||||
mkdir '${CGAL_BINARY_DIR}/test'
|
||||
|
||||
cp '${CGAL_TEST_DIR}/collect_cgal_testresults_from_cmake' '${CGAL_BINARY_DIR}/test'
|
||||
cp '${CGAL_TEST_DIR}/makefile2' '${CGAL_BINARY_DIR}/test'
|
||||
cp '${CGAL_TEST_DIR}/run_testsuite_with_cmake' '${CGAL_BINARY_DIR}/test'
|
||||
|
||||
# list all packages in CGAL_TEST_DIR. If PACKAGE is found in LIST_TEST_PACKAGES,
|
||||
# copy it, else prepare for the special "skipped" case in the table.
|
||||
for PACKAGE in \$(ls "${CGAL_TEST_DIR}"); do
|
||||
if [ -d "${CGAL_TEST_DIR}/\$PACKAGE" ]; then
|
||||
if source '${LIST_TEST_PACKAGES}' '${CGAL_ROOT}' | grep -E -q \$PACKAGE; then
|
||||
mkdir "${CGAL_BINARY_DIR}/test/\${PACKAGE}"
|
||||
cp -r "${CGAL_TEST_DIR}/\${PACKAGE}" '${CGAL_BINARY_DIR}/test'
|
||||
elif [ "\$PACKAGE" = "resources" ]; then
|
||||
mkdir "${CGAL_BINARY_DIR}/test/\${PACKAGE}"
|
||||
cp -r "${CGAL_TEST_DIR}/\${PACKAGE}" '${CGAL_BINARY_DIR}/test'
|
||||
else
|
||||
mkdir "${CGAL_BINARY_DIR}/test/\${PACKAGE}"
|
||||
touch "${CGAL_BINARY_DIR}/test/\${PACKAGE}/skipped"
|
||||
fi
|
||||
fi
|
||||
|
||||
done
|
||||
|
||||
else
|
||||
cp -r '${CGAL_TEST_DIR}' '${CGAL_BINARY_DIR}/test';
|
||||
fi
|
||||
|
||||
cd '${CGAL_BINARY_DIR}/test';
|
||||
if [ -n "\${ULIMIT_OPTIONS}" ]; then
|
||||
eval ulimit \${ULIMIT_OPTIONS};
|
||||
else
|
||||
[ -n "${ULIMIT_OPTIONS}" ] && ulimit ${ULIMIT_OPTIONS};
|
||||
fi
|
||||
nice ${NICE_OPTIONS} make ${MAKE_OPTS} -k -fmakefile2;
|
||||
EOF
|
||||
for file in "${CGAL_BINARY_DIR}/localtestscript" "${CGAL_BINARY_DIR}/localtestscript-redo-results-collection"; do
|
||||
cat >> "$file" <<EOF
|
||||
echo 'COLLECTING RESULTS';
|
||||
./collect_cgal_testresults_from_cmake;
|
||||
if [ -n "\$COLLECT_DEMOS_BINARIES" ]; then
|
||||
echo 'COLLECTING DEMOS BINARIES';
|
||||
echo "cp ${CGAL_TEST_DIR}/../developer_scripts/cgal_demo_copy_all_dlls_cygwin.sh ${CGAL_BINARY_DIR}/test"
|
||||
cp "${CGAL_TEST_DIR}/../developer_scripts/cgal_demo_copy_all_dlls_cygwin.sh" "${CGAL_BINARY_DIR}/test"
|
||||
EOF
|
||||
cat >> "$file" <<'EOF'
|
||||
for demo_dir in *_Demo; do
|
||||
echo "pushd ${demo_dir}"
|
||||
pushd "${demo_dir}"
|
||||
bash ../cgal_demo_copy_all_dlls_cygwin.sh "${demo_dir}_with_dlls" ""
|
||||
mv "${demo_dir}_with_dlls" ..
|
||||
popd
|
||||
done
|
||||
EOF
|
||||
cat >> "$file" <<EOF
|
||||
tar czvf "${CGAL_TEST_DIR}/demos_${CGAL_TESTER}_${PLATFORM}.tar.gz" *_Demo_with_dlls/*
|
||||
fi
|
||||
echo 'COPYING RESULTS';
|
||||
cp 'results_${CGAL_TESTER}_${PLATFORM}.tar.gz' 'results_${CGAL_TESTER}_${PLATFORM}.txt' '${CGAL_TEST_DIR}';
|
||||
cd ..;
|
||||
EOF
|
||||
done
|
||||
if [ -z "${KEEP_TESTS}" ]; then
|
||||
cat >> "${CGAL_BINARY_DIR}/localtestscript" <<EOF
|
||||
echo 'REMOVING LOCAL_TEST_DIR';
|
||||
rm -rf '${CGAL_BINARY_DIR}/test'
|
||||
EOF
|
||||
fi
|
||||
|
||||
|
||||
chmod ugo+x "${CGAL_BINARY_DIR}"/localtestscript*
|
||||
|
||||
if [ -n "${SHOW_PROGRESS}" ]; then
|
||||
remote_command ${HOST} "${CGAL_BINARY_DIR}/localtestscript" 2>&1 | tee "${ACTUAL_LOGFILE}.test.${PLATFORM}"
|
||||
else
|
||||
remote_command ${HOST} "${CGAL_BINARY_DIR}/localtestscript" > "${ACTUAL_LOGFILE}.test.${PLATFORM}" 2>&1
|
||||
fi
|
||||
|
||||
log_done "${ACTUAL_LOGFILE}.test.${PLATFORM}"
|
||||
|
||||
fi
|
||||
}
|
||||
|
||||
publish_results()
|
||||
{
|
||||
HOST=${1}
|
||||
PLATFORM=${2}
|
||||
|
||||
#
|
||||
# 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
|
||||
|
||||
#
|
||||
# notify the CGAL world
|
||||
#
|
||||
if [ ! "${MAIL_ADDRESS}" = "must_be_set_in_.autocgalrc" ]; then
|
||||
for i in ${MAIL_ADDRESS}; do
|
||||
echo "Notifying ${i} about autotest finished."
|
||||
printf "result collection::\n${FILENAME}\n" | ${SENDMAIL} -s "autohandle" ${i}
|
||||
done
|
||||
fi
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# Runs the test on the host $1
|
||||
# ----------------------------------------------------------------------------------------
|
||||
run_test_on_host()
|
||||
{
|
||||
HOST=${1}
|
||||
|
||||
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_host_and_platform "${HOST}" "${PLATFORM}"
|
||||
publish_results "${HOST}" "${PLATFORM}"
|
||||
done
|
||||
}
|
||||
|
||||
# ----------------------------------------------------------------------------------------
|
||||
# run the testsuites
|
||||
# ----------------------------------------------------------------------------------------
|
||||
run_test()
|
||||
{
|
||||
log "${ACTUAL_LOGFILE}" "running the testsuites"
|
||||
if [ -n "${CONSOLE_OUTPUT}" ]; then
|
||||
printf "\n-------------------------------------------------------\n"
|
||||
fi
|
||||
|
||||
for HOST in ${BUILD_HOSTS}; do
|
||||
run_test_on_host ${HOST} &
|
||||
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}"
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
# ----------------------------------------------------
|
||||
# START OF MAIN BODY
|
||||
# ----------------------------------------------------
|
||||
|
||||
# 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 "$HOME/.autocgal_with_cmake_rc" ]; then
|
||||
. "$HOME/.autocgal_with_cmake_rc"
|
||||
else
|
||||
if [ -f "$HOME/.autocgalrc" ]; then
|
||||
. "$HOME/.autocgalrc"
|
||||
else
|
||||
echo "CONFIGURATION FILE .autocgal_with_cmake_rc or .autocgalrc NOT FOUND" >&2;
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
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}"
|
||||
|
||||
# Sanity checks
|
||||
if [ "${REFERENCE_PLATFORMS_DIR}" = "must_be_set_in_.autocgalrc" ]; then
|
||||
error "REFERENCE_PLATFORMS_DIR must be set in .autocaglrc"
|
||||
fi
|
||||
|
||||
if [ "${BUILD_HOSTS}" = "must_be_set_in_.autocgalrc" ]; then
|
||||
error "BUILD_HOSTS must be set in .autocgalrc"
|
||||
else
|
||||
for i in ${BUILD_HOSTS}; do
|
||||
TEXT="`value_of COMPILERS_${i}`"
|
||||
if [ -z "${TEXT}" -a "${i}" != "localhost" ]; then
|
||||
error "COMPILERS_${i} must be defined in .autocgalrc"
|
||||
else
|
||||
TEXT="`value_of PROCESSORS_${i}`"
|
||||
TEMPVAR="PROCESSORS_${i}"
|
||||
if [ -z "${TEXT}" ]; then
|
||||
log "${ACTUAL_LOGFILE}" "\ngiving default 1 values TO PROCESSORS_${i} ...";
|
||||
eval $TEMPVAR="1";
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
# Make that file writable (lockfile create read-only files
|
||||
chmod u+w "$LOCK_FILE"
|
||||
# Put the PID of current process in the lock file
|
||||
echo $$ > "$LOCK_FILE"
|
||||
|
||||
fi
|
||||
|
||||
# that line makes the script remove the lock file in case of unwanted exit
|
||||
trap "rm -f \"$LOCK_FILE\"" EXIT HUP INT TERM
|
||||
|
||||
# Notify test started
|
||||
if [ ! "${MAIL_ADDRESS}" = "must_be_set_in_.autocgalrc" ]; then
|
||||
for i in ${MAIL_ADDRESS}; do
|
||||
echo "Notifying ${i} about autotest started."
|
||||
printf "subject says it all\n" | \
|
||||
${SENDMAIL} -s "Started autotest" ${i}
|
||||
done
|
||||
fi
|
||||
|
||||
|
||||
|
||||
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
|
||||
|
||||
setup_dirs
|
||||
|
||||
copy_old_stuff
|
||||
|
||||
build_cgal
|
||||
|
||||
if [ "${BUILD_HOSTS}" = "localhost" ]; then
|
||||
TEXT="`value_of COMPILERS_localhost`"
|
||||
if [ -z "${DO_NOT_TEST}" ]; then
|
||||
if [ -z "${TEXT}" ]; then
|
||||
printf "Skipping testing phase (use the -n option to remove this message).\n"
|
||||
DO_NOT_TEST="y"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ -z "${DO_NOT_TEST}" ]; then
|
||||
run_test
|
||||
fi
|
||||
|
||||
cd "${CGAL_ROOT}"
|
||||
|
||||
if [ -e "LATEST" ]; then
|
||||
mv LATEST RELEASE_NR
|
||||
fi
|
||||
|
||||
rm -f "$LOCK_FILE";
|
||||
|
||||
# EOF
|
||||
|
||||
## Local Variables:
|
||||
## sh-basic-offset: 2
|
||||
## End:
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
#!/bin/sh
|
||||
|
||||
exec ${0%_with_cmake} ${1+"$@"}
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
#To run: $1 = name of the user
|
||||
# $2 = name of the branch
|
||||
# $3 = base ref name (master, 5.1.x, 5.2.x, etc...)
|
||||
# $4 = number of the PR
|
||||
|
||||
|
||||
if uname | grep -q -i cygwin; then
|
||||
#Is supposed to ignore \r as eol character.
|
||||
export SHELLOPTS
|
||||
set -o igncr
|
||||
fi
|
||||
source ~/.autofilterrc
|
||||
(
|
||||
USER_REPO=$1
|
||||
BRANCH_NAME=$2
|
||||
BASE_NAME=$3
|
||||
PR_NUMBER=$4
|
||||
|
||||
|
||||
cd ${CGAL_GIT_DIR}
|
||||
if [ ! -d cgal ]; then
|
||||
git clone https://github.com/CGAL/cgal.git
|
||||
cd cgal
|
||||
git remote rename origin cgal
|
||||
cd ..
|
||||
fi
|
||||
cd cgal
|
||||
git fetch cgal
|
||||
git remote add $USER_REPO https://github.com/$USER_REPO/cgal.git
|
||||
git fetch $USER_REPO
|
||||
git checkout $BRANCH_NAME
|
||||
git reset --hard $USER_REPO/$BRANCH_NAME
|
||||
#setup the list_test_packages
|
||||
TMP_LIST=$(git diff --name-only cgal/$BASE_NAME...HEAD |grep -E -v /doc |grep -E "\.h"\|"\.cpp" |cut -s -d/ -f1 |sort -u | xargs -I {} ls -d {}/package_info 2>/dev/null |cut -d/ -f1 |grep -E -v Installation||true)
|
||||
|
||||
LIST_OF_PKGS=""
|
||||
for PKG in $(ls) ; do
|
||||
if [ -f $PKG/package_info/$PKG/dependencies ]; then
|
||||
if [ -n "$(comm -12 <(echo "$TMP_LIST"|sort) <(cat $PKG/package_info/$PKG/dependencies|sort))" ]; then
|
||||
LIST_OF_PKGS="$LIST_OF_PKGS $PKG"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
if [ -f ${CGAL_ROOT}/list_test_packages ]; then rm ${CGAL_ROOT}/list_test_packages; fi
|
||||
if [ "$LIST_OF_PKGS" != "" ]; then
|
||||
for f in $LIST_OF_PKGS
|
||||
do
|
||||
echo "echo \"$f\"" >> ${CGAL_ROOT}/list_test_packages
|
||||
echo "echo \"${f}_Examples\"" >> ${CGAL_ROOT}/list_test_packages
|
||||
echo "echo \"${f}_Demo\"" >> ${CGAL_ROOT}/list_test_packages
|
||||
done
|
||||
fi
|
||||
#create the release from the branch
|
||||
echo " Create release..."
|
||||
CGAL_VERSION="$(sed -E 's/#define CGAL_VERSION (.*\..*)-dev/\1/' <(grep "#define CGAL_VERSION " Installation/include/CGAL/version.h))-Ic-${PR_NUMBER}"
|
||||
cmake -DGIT_REPO=${CGAL_GIT_DIR}/cgal -DDESTINATION=${CGAL_ROOT}/CGAL-TEST -DPUBLIC=OFF -DTESTSUITE=ON -DCGAL_VERSION=${CGAL_VERSION} -P ${CGAL_GIT_DIR}/cgal/Scripts/developer_scripts/cgal_create_release_with_cmake.cmake | tee log
|
||||
echo "done."
|
||||
DEST=$(sed -E 's/.*CGAL-TEST\/(.*)/\1/' log);
|
||||
|
||||
cd ${CGAL_ROOT}
|
||||
|
||||
if [ -L CGAL-I ]; then rm CGAL-I; fi
|
||||
ln -s $PWD/CGAL-TEST/$DEST CGAL-I
|
||||
if [ -d CGAL-I/cmake/platforms ]; then
|
||||
rm -rf CGAL-I/cmake/platforms/*
|
||||
fi
|
||||
echo "starting testsuite..."
|
||||
|
||||
./autotest_cgal -c
|
||||
|
||||
echo "finished."
|
||||
)>${CGAL_ROOT}/autotest.log2 2>&1 &
|
||||
|
||||
echo "exit."
|
||||
exit 0
|
||||
|
|
@ -1,283 +0,0 @@
|
|||
#!/bin/sh
|
||||
# collect_cgal_testresults_from_cmake
|
||||
# ===================================
|
||||
# collect all files to generate the html page
|
||||
# containing the testsuite results
|
||||
#
|
||||
# to be run in the CGAL/test directory or a local test directory.
|
||||
# CGAL_TESTER, CGAL_TESTER_NAME, CGAL_TESTER_ADDRESS are environment variables.
|
||||
|
||||
|
||||
if [ -z "${CGAL_TEST_PLATFORM}" ]; then
|
||||
|
||||
CGAL_TEST_PLATFORM=`dirname $PWD`
|
||||
echo "CGAL_TEST_PLATFORM not in the environment, setting it to ${CGAL_TEST_PLATFORM}"
|
||||
fi
|
||||
|
||||
if [ -z "$1" ] ; then
|
||||
TEST_DIRECTORIES=`ls`
|
||||
else
|
||||
TEST_DIRECTORIES="$*"
|
||||
fi
|
||||
|
||||
GENERAL_BUILD_LOGFILE=''
|
||||
PLATFORM_BUILD_LOGFILE=''
|
||||
TEST_REPORT=''
|
||||
RESULT_FILE=''
|
||||
|
||||
#print_testresult <platform> <directory>
|
||||
# print result on stdout
|
||||
# print timings on fd3
|
||||
print_testresult()
|
||||
{
|
||||
if [ -f skipped ]; then
|
||||
RESULT="s"
|
||||
TIMING="0"
|
||||
elif [ ! -f ErrorOutput_$1 ] ; then
|
||||
RESULT="?"
|
||||
TIMING="?"
|
||||
else
|
||||
if eval grep ERROR ErrorOutput_$1 > /dev/null ; then
|
||||
RESULT="n"
|
||||
else
|
||||
# grep -q means "quiet": no output, the return code is 0 iff the file
|
||||
# matches the regular expression.
|
||||
# grep -i means "case insensitive".
|
||||
# grep -E means "extended regular expressions".
|
||||
# All those three options are in the Single Unix Specification version 3
|
||||
|
||||
# The extended regular expression '[^a-zA-Z_,:-]warning matches any
|
||||
# string "warning" preceded with a letter that is not a letter or '_'
|
||||
# or ',' or ':'. That avoids some false positives such as
|
||||
# '-read_only_relocs,warning' or '-D_CRT_SECURE_NO_WARNINGS', or
|
||||
# 'QMessageBox::warning'.
|
||||
if grep -v -F 'CMake Warning at /usr/share/cmake/Modules/FindBoost' CompilerOutput_$1 ProgramOutput.*.$1 | grep -i -E -q '(^|[^a-zA-Z_,:-])warning'
|
||||
then
|
||||
if grep -v -F 'CMake Warning at /usr/share/cmake/Modules/FindBoost' CompilerOutput_$1 ProgramOutput.*.$1 | grep -i -E '(^|[^a-zA-Z_,:-])warning' | grep -i -q "include[/\]CGAL\|cmake\|CGAL warning"
|
||||
then
|
||||
RESULT="w"
|
||||
else
|
||||
RESULT="t"
|
||||
fi
|
||||
else
|
||||
if grep -E -q 'NOTICE: .*(need|require|incompatible|not found).*will not be' CompilerOutput_$1
|
||||
then
|
||||
RESULT="r"
|
||||
else
|
||||
RESULT="y"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
TIMING=`awk '/^ # Running time: / {print $4}' < ErrorOutput_$1`
|
||||
fi
|
||||
echo "$2 $TIMING" >&3
|
||||
echo "$2 $RESULT"
|
||||
}
|
||||
|
||||
parse_flags_and_third_party_choices()
|
||||
{
|
||||
grep -e "^-- USING " ${PLATFORM_BUILD_LOGFILE} >> $RESULT_FILE
|
||||
echo "------------" >> $RESULT_FILE
|
||||
}
|
||||
|
||||
|
||||
output_main_logs()
|
||||
{
|
||||
[ -e Installation ] || mkdir "Installation"
|
||||
|
||||
INSTALLATION_TEST_REPORT="Installation/$TEST_REPORT"
|
||||
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " General Build Log " >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "${GENERAL_BUILD_LOGFILE}" ] ; then
|
||||
cat "${GENERAL_BUILD_LOGFILE}" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " Platform-specific Build Log " >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "${PLATFORM_BUILD_LOGFILE}" ] ; then
|
||||
cat "${PLATFORM_BUILD_LOGFILE}" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
if [ -f "$HOME/.autocgal_with_cmake_rc" ] ; then
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " .autocgal_with_cmake_rc" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
cat "$HOME/.autocgal_with_cmake_rc" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
if [ -f "$HOME/.autocgalrc" ] ; then
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " .autocgalrc" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
cat "$HOME/.autocgalrc" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ -f "../setup" ] ; then
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " setup" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
cat "../setup" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " CMakeCache.txt" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "../CMakeCache.txt" ] ; then
|
||||
cat "../CMakeCache.txt" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " include/CGAL/compiler_config.h" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "../include/CGAL/compiler_config.h" ] ; then
|
||||
cat "../include/CGAL/compiler_config.h" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " CGALConfig.cmake" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "../CGALConfig.cmake" ] ; then
|
||||
cat "../CGALConfig.cmake" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " CMakeError.log" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "../CMakeFiles/CMakeError.log" ] ; then
|
||||
cat "../CMakeFiles/CMakeError.log" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo " CMakeOutput.log" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "---------------------------------------------------------------" >> "$INSTALLATION_TEST_REPORT"
|
||||
echo "" >> "$INSTALLATION_TEST_REPORT"
|
||||
if [ -f "../CMakeFiles/CMakeOutput.log" ] ; then
|
||||
cat "../CMakeFiles/CMakeOutput.log" >> "$INSTALLATION_TEST_REPORT"
|
||||
else
|
||||
echo "Not found!" >> "$INSTALLATION_TEST_REPORT"
|
||||
fi
|
||||
|
||||
}
|
||||
|
||||
echo "---------------------------------------------------------------"
|
||||
echo " Collecting results of platform $CGAL_TEST_PLATFORM"
|
||||
echo "---------------------------------------------------------------"
|
||||
|
||||
CURRENT_DIR=`pwd`
|
||||
TESTER=${CGAL_TESTER:-${USER:-`whoami`}}
|
||||
TESTER_NAME="${CGAL_TESTER_NAME:-${TESTER}}"
|
||||
TESTER_ADDRESS="${CGAL_TESTER_ADDRESS:-${TESTER}}"
|
||||
TEST_REPORT="TestReport_${TESTER}_${CGAL_TEST_PLATFORM}"
|
||||
RESULT_FILE="$CURRENT_DIR/results_${TESTER}_${CGAL_TEST_PLATFORM}.txt"
|
||||
TIMING_FILE="$CURRENT_DIR/timings_${TESTER}_${CGAL_TEST_PLATFORM}.txt"
|
||||
CGAL_DIR=../../../..
|
||||
GENERAL_BUILD_LOGFILE="../../installation.log"
|
||||
PLATFORM_BUILD_LOGFILE="../installation.log"
|
||||
rm -f "$RESULT_FILE" "$TIMING_FILE"
|
||||
touch "$RESULT_FILE" "$TIMING_FILE"
|
||||
sed -n '/CGAL_VERSION /s/#define //p' < "$CGAL_DIR/include/CGAL/version.h" >> "$RESULT_FILE"
|
||||
echo "TESTER ${TESTER}" >> "$RESULT_FILE"
|
||||
echo "TESTER_NAME ${TESTER_NAME}" >> "$RESULT_FILE"
|
||||
echo "TESTER_ADDRESS ${TESTER_ADDRESS}" >> "$RESULT_FILE"
|
||||
echo "CGAL_TEST_PLATFORM ${CGAL_TEST_PLATFORM}" >> "$RESULT_FILE"
|
||||
echo "General installation log file: ${GENERAL_BUILD_LOGFILE}" >> "$RESULT_FILE"
|
||||
echo "Host-specific installation log file: ${PLATFORM_BUILD_LOGFILE}" >> "$RESULT_FILE"
|
||||
|
||||
output_main_logs
|
||||
|
||||
parse_flags_and_third_party_choices
|
||||
|
||||
for DIR in $TEST_DIRECTORIES ; do
|
||||
if [ -d "$DIR" ] ; then
|
||||
echo " $DIR ..."
|
||||
cd "$DIR"
|
||||
|
||||
print_testresult "$CGAL_TEST_PLATFORM" "$DIR" >> "$RESULT_FILE" 3>>"$TIMING_FILE"
|
||||
|
||||
if [ ! "$DIR" = "Installation" ] ; then
|
||||
rm -f "${TEST_REPORT}"
|
||||
touch "$TEST_REPORT"
|
||||
fi
|
||||
if [ -f .scm-urls ]; then
|
||||
echo " Test files from:" >> "$TEST_REPORT"
|
||||
cat .scm-urls >> "$TEST_REPORT"
|
||||
echo >> "$TEST_REPORT"
|
||||
elif [ -f ../../../../../.scm-branch ]; then
|
||||
cat ../../../../../.scm-branch >> "$TEST_REPORT"
|
||||
echo >> "$TEST_REPORT"
|
||||
fi
|
||||
|
||||
if [ ! -f ErrorOutput_${CGAL_TEST_PLATFORM} ] ; then
|
||||
echo "Error: file $DIR/ErrorOutput_${CGAL_TEST_PLATFORM} does not exist!"
|
||||
else
|
||||
cat ErrorOutput_${CGAL_TEST_PLATFORM} >> "$TEST_REPORT"
|
||||
fi
|
||||
|
||||
if [ ! -f CompilerOutput_${CGAL_TEST_PLATFORM} ] ; then
|
||||
echo "Error: file $DIR/CompilerOutput_${CGAL_TEST_PLATFORM} does not exist!"
|
||||
else
|
||||
cat CompilerOutput_${CGAL_TEST_PLATFORM} >> "$TEST_REPORT"
|
||||
fi
|
||||
|
||||
if 2>&1 eval ls ProgramOutput.*.${CGAL_TEST_PLATFORM} > /dev/null ; then
|
||||
PROGRAM_OUTPUT=`ls ProgramOutput.*"$CGAL_TEST_PLATFORM"*`
|
||||
for FILE in $PROGRAM_OUTPUT ; do
|
||||
echo >> "$TEST_REPORT"
|
||||
echo "------------------------------------------------------------------" >> "$TEST_REPORT"
|
||||
echo "- $FILE" >> "$TEST_REPORT"
|
||||
echo "------------------------------------------------------------------" >> "$TEST_REPORT"
|
||||
cat $FILE >> "$TEST_REPORT"
|
||||
done
|
||||
fi
|
||||
|
||||
cd ..
|
||||
fi
|
||||
done
|
||||
|
||||
|
||||
OUTPUT_FILE=results_${TESTER}_${CGAL_TEST_PLATFORM}.tar
|
||||
rm -f $OUTPUT_FILE $OUTPUT_FILE.gz
|
||||
tar cf $OUTPUT_FILE results_${TESTER}_${CGAL_TEST_PLATFORM}.txt timings_${TESTER}_${CGAL_TEST_PLATFORM}.txt */"$TEST_REPORT"
|
||||
echo
|
||||
echo "compressing ..."
|
||||
gzip -9f $OUTPUT_FILE
|
||||
echo "results written to file $OUTPUT_FILE.gz"
|
||||
echo
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# standard-indent: 2
|
||||
# End:
|
||||
|
|
@ -1,263 +0,0 @@
|
|||
#! /bin/sh
|
||||
#
|
||||
# This is the test script for the CGAL-library.
|
||||
#
|
||||
# Usage:
|
||||
# run_testsuite for running the test suite in all subdirectories
|
||||
# run_testsuite <directory-list> for running the test suite in the listed
|
||||
# subdirectories
|
||||
#
|
||||
# To use this script you have to do two things:
|
||||
#
|
||||
# 2) set some additional compiler and or linker flags
|
||||
|
||||
TESTSUITE_CXXFLAGS=""
|
||||
TESTSUITE_LDFLAGS=""
|
||||
|
||||
CURRENTDIR=`pwd`
|
||||
ERRORFILE=${CURRENTDIR}/error.txt
|
||||
if [ -n "$CGAL_TEST_PLATFORM" ]; then
|
||||
PLATFORM=$CGAL_TEST_PLATFORM
|
||||
else
|
||||
PLATFORM=no-platform
|
||||
fi
|
||||
if [ -n "${CGAL_TIMEOUT_PROG+x}" ]; then
|
||||
TIMEOUT=$CGAL_TIMEOUT_PROG
|
||||
else
|
||||
TIMEOUT=`which timeout`
|
||||
[ -z "$TIMEOUT" ] && TIMEOUT=`which gtimeout`
|
||||
fi
|
||||
|
||||
#clear the error file
|
||||
rm -f "$ERRORFILE"
|
||||
touch "$ERRORFILE"
|
||||
|
||||
# On Cygwin, killing bash does not kill jobs it has spawned. This
|
||||
# function takes a PID as argument and prints the list of children
|
||||
# processes of this process, including itself.
|
||||
process_tree()
|
||||
{
|
||||
local pid=$1
|
||||
local result=
|
||||
echo $pid
|
||||
ps -a | awk '!/^ +PID/ {print $1 " " $2}' | {
|
||||
while read apid appid; do
|
||||
if [ "$appid" = "$pid" ]; then
|
||||
process_tree $apid
|
||||
fi
|
||||
done
|
||||
}
|
||||
}
|
||||
|
||||
# Wait for process with pid $1.
|
||||
# Wait for $2 periods of $3 seconds, checking after every period
|
||||
# if the watched process has finished.
|
||||
wait_for_process()
|
||||
{
|
||||
pid=$1;
|
||||
cycles=$2
|
||||
period=$3
|
||||
while [ $cycles -ne 0 ]
|
||||
do
|
||||
cycles=`expr $cycles - 1`
|
||||
# send SIGCONT to the process and check the exit value of kill.
|
||||
# If the process still exists, the call to kill succeeds (and the signal is
|
||||
# ignored).
|
||||
|
||||
kill -CONT $pid 2>kill_output 1>/dev/null; terminated=$?
|
||||
# But under CYGWIN the exit status is not to be trusted.
|
||||
if [ $terminated -eq 0 ]; then
|
||||
if grep -i 'no such process' kill_output; then
|
||||
terminated=1;
|
||||
fi
|
||||
fi
|
||||
rm -f kill_output
|
||||
if [ $terminated -eq 0 ]
|
||||
then
|
||||
sleep $period
|
||||
else
|
||||
cycles=0
|
||||
running=0
|
||||
fi
|
||||
done
|
||||
if [ $terminated -eq 0 ]
|
||||
then
|
||||
if false; then
|
||||
# Send signal Terminate (SIGTERM) to the whole process group.
|
||||
# First disable the default action (quit) for the current process.
|
||||
trap true TERM
|
||||
kill -TERM 0
|
||||
trap TERM
|
||||
else
|
||||
|
||||
# $pid is the PID of the forked shell that launched the command
|
||||
# in background, in run_local_cgal_test(). If the shell is
|
||||
# Bash, the Bash manual states that it ignores SIGTERM.
|
||||
# However, it does not catch SIGHUP. That is why the first
|
||||
# signal send is SIGHUP.
|
||||
case "`uname`" in
|
||||
CYGWIN*)
|
||||
pids=`process_tree $pid`;;
|
||||
*) pids=$pid;;
|
||||
esac
|
||||
for p in $pids; do kill -HUP $p; done
|
||||
sleep 10
|
||||
# If SIGHUP was not enough, SIGKILL will finish the job, 10s after.
|
||||
for p in $pids; do kill -KILL $p 2>/dev/null; done
|
||||
fi
|
||||
return 1
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
run_local_cgal_test()
|
||||
{
|
||||
# Workaround an issue on Windows when GNU Make is used for "make -f
|
||||
# makefile2" but nmake is used after.
|
||||
MAKEFLAGS=
|
||||
export MAKEFLAGS
|
||||
|
||||
if [ -n "$TIMEOUT" ]; then
|
||||
"$TIMEOUT" $(( $TIME_PERIOD * 5 )) ./cgal_test_with_cmake > current_compiler_output 2>&1
|
||||
else
|
||||
./cgal_test_with_cmake > current_compiler_output 2>&1
|
||||
fi
|
||||
exit_value=$?
|
||||
if [ $exit_value -ne 0 ]
|
||||
then
|
||||
printf "%s\n" "$exit_value" > test_failure
|
||||
fi
|
||||
return $exit_value
|
||||
}
|
||||
|
||||
#test_directory <directory> <already_here>
|
||||
# test_directory() may call itself once: the second parameter avoids that
|
||||
# it calls itself infinitely.
|
||||
test_directory()
|
||||
{
|
||||
cd "$CURRENTDIR"
|
||||
if [ -d $1 ] ; then
|
||||
echo "DIRECTORY $1:"
|
||||
echo
|
||||
|
||||
echo "DIRECTORY $1:" >> "$ERRORFILE"
|
||||
echo >> "$ERRORFILE"
|
||||
cd "$1"
|
||||
|
||||
COMPILER_OUTPUT=CompilerOutput_$PLATFORM
|
||||
rm -f "$COMPILER_OUTPUT"
|
||||
ERROR_OUTPUT=ErrorOutput_$PLATFORM
|
||||
rm -f "$ERROR_OUTPUT"
|
||||
|
||||
echo "------------------------------------------------------------------" >> "$COMPILER_OUTPUT"
|
||||
echo "- Compiler output from platform $PLATFORM" >> "$COMPILER_OUTPUT"
|
||||
echo "------------------------------------------------------------------" >> "$COMPILER_OUTPUT"
|
||||
echo >> "$COMPILER_OUTPUT"
|
||||
|
||||
echo "------------------------------------------------------------------" >> "$ERROR_OUTPUT"
|
||||
echo "- Error output from platform $PLATFORM" >> "$ERROR_OUTPUT"
|
||||
echo "------------------------------------------------------------------" >> "$ERROR_OUTPUT"
|
||||
echo >> "$ERROR_OUTPUT"
|
||||
|
||||
if [ -f cgal_test_with_cmake -a -x cgal_test_with_cmake ] ; then
|
||||
export PLATFORM TESTSUITE_CXXFLAGS TESTSUITE_LDFLAGS
|
||||
rm -f error.txt
|
||||
START=`date +%s`
|
||||
TIME_PERIOD=1200
|
||||
if [ "$1" = "Polyhedron_Demo" ]; then
|
||||
TIME_PERIOD=2400
|
||||
fi
|
||||
if [ -n "$TIMEOUT" ]; then
|
||||
run_local_cgal_test
|
||||
return_code=$?
|
||||
if [ $return_code -eq 124 ]; then
|
||||
echo "ERROR: cgal_test_with_cmake did not finish within the time bound set" >> "$ERRORFILE"
|
||||
echo "ERROR: cgal_test_with_cmake did not finish within the time bound set" >> "$ERROR_OUTPUT"
|
||||
else
|
||||
if [ -f test_failure ] ; then
|
||||
exit_failure=`cat test_failure`
|
||||
rm -f test_failure
|
||||
echo "ERROR: cgal_test_with_cmake exited with error condition $exit_value" >> "$ERRORFILE"
|
||||
echo "ERROR: cgal_test_with_cmake exited with error condition $exit_value" >> "$ERROR_OUTPUT"
|
||||
fi
|
||||
fi
|
||||
else
|
||||
run_local_cgal_test &
|
||||
|
||||
if wait_for_process "$!" "$TIME_PERIOD" "5"
|
||||
then
|
||||
if [ -f test_failure ] ; then
|
||||
exit_failure=`cat test_failure`
|
||||
rm -f test_failure
|
||||
echo "ERROR: cgal_test_with_cmake exited with error condition $exit_value" >> "$ERRORFILE"
|
||||
echo "ERROR: cgal_test_with_cmake exited with error condition $exit_value" >> "$ERROR_OUTPUT"
|
||||
fi
|
||||
else
|
||||
echo "ERROR: cgal_test_with_cmake did not finish within the time bound set" >> "$ERRORFILE"
|
||||
echo "ERROR: cgal_test_with_cmake did not finish within the time bound set" >> "$ERROR_OUTPUT"
|
||||
fi
|
||||
fi
|
||||
STOP=`date +%s`
|
||||
DURATION=`expr "$STOP" - "$START"`
|
||||
printf " # Running time: %s (seconds)\n\n" "$DURATION" >> "$ERRORFILE"
|
||||
printf " # Running time: %s (seconds)\n\n" "$DURATION" >> "$ERROR_OUTPUT"
|
||||
cat current_compiler_output >> "$COMPILER_OUTPUT"
|
||||
cat current_compiler_output
|
||||
rm -f current_compiler_output
|
||||
|
||||
if [ -f error.txt ] ; then
|
||||
cat error.txt >> "$ERRORFILE"
|
||||
cat error.txt >> "$ERROR_OUTPUT"
|
||||
else
|
||||
echo "ERROR: the script cgal_test_with_cmake failed to generate output" >> "$ERRORFILE"
|
||||
fi
|
||||
else
|
||||
if [ -z "$2" ]; then
|
||||
create_cgal_test
|
||||
test_directory "$1" "second_time"
|
||||
else
|
||||
echo " Could not execute the script cgal_test_with_cmake in directory $1"
|
||||
echo "ERROR: could not execute the script $1/cgal_test_with_cmake" >> $ERRORFILE
|
||||
fi
|
||||
fi
|
||||
echo >> "$ERRORFILE"
|
||||
echo >> "$ERROR_OUTPUT"
|
||||
fi
|
||||
echo
|
||||
}
|
||||
|
||||
run_testsuite()
|
||||
{
|
||||
|
||||
echo "---------------------------------------------------------------"
|
||||
echo "- Testing platform $PLATFORM"
|
||||
echo "---------------------------------------------------------------"
|
||||
echo
|
||||
|
||||
echo "---------------------------------------------------------------" >> "$ERRORFILE"
|
||||
echo "- TEST RESULTS FROM PLATFORM $PLATFORM" >> "$ERRORFILE"
|
||||
echo "---------------------------------------------------------------" >> "$ERRORFILE"
|
||||
echo >> "$ERRORFILE"
|
||||
|
||||
case "`uname`" in
|
||||
CYGWIN*)
|
||||
PATH=`cygpath "$CGAL_DIR"`/bin:`cygpath "$CGAL_DIR"`/lib:$PATH
|
||||
export PATH
|
||||
esac
|
||||
|
||||
for DIR in $TEST_DIRECTORIES ; do
|
||||
if [ ! -f $DIR/skipped ]; then
|
||||
test_directory "$DIR"
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
[ x"$1" = x"icons" -o x"$1" = x"resources" ] && exit 0
|
||||
|
||||
if [ -z "$1" ] ; then
|
||||
TEST_DIRECTORIES=`ls | grep -E -v 'icons|resources'`
|
||||
else
|
||||
TEST_DIRECTORIES="$*"
|
||||
fi
|
||||
|
||||
run_testsuite
|
||||
Loading…
Reference in New Issue