aboutsummaryrefslogtreecommitdiffstats
path: root/lib/test_server/src
diff options
context:
space:
mode:
Diffstat (limited to 'lib/test_server/src')
-rw-r--r--lib/test_server/src/Makefile145
-rw-r--r--lib/test_server/src/conf_vars.in25
l---------lib/test_server/src/config.guess1
l---------lib/test_server/src/config.sub1
-rw-r--r--lib/test_server/src/configure.in423
-rw-r--r--lib/test_server/src/cross.cover20
-rw-r--r--lib/test_server/src/erl2html2.erl182
l---------lib/test_server/src/install-sh1
-rw-r--r--lib/test_server/src/test_server.app.src36
-rw-r--r--lib/test_server/src/test_server.appup.src1
-rw-r--r--lib/test_server/src/test_server.erl2203
-rw-r--r--lib/test_server/src/test_server_ctrl.erl5253
-rw-r--r--lib/test_server/src/test_server_h.erl129
-rw-r--r--lib/test_server/src/test_server_internal.hrl59
-rw-r--r--lib/test_server/src/test_server_line.erl380
-rw-r--r--lib/test_server/src/test_server_node.erl1013
-rw-r--r--lib/test_server/src/test_server_sup.erl616
-rw-r--r--lib/test_server/src/things/distr_startup_SUITE.erl238
-rw-r--r--lib/test_server/src/things/mnesia_power_SUITE.erl125
-rw-r--r--lib/test_server/src/things/random_kill_SUITE.erl81
-rw-r--r--lib/test_server/src/things/soft.gs.txt16
-rw-r--r--lib/test_server/src/things/verify.erl199
-rw-r--r--lib/test_server/src/ts.config45
-rw-r--r--lib/test_server/src/ts.erl695
-rw-r--r--lib/test_server/src/ts.hrl36
-rw-r--r--lib/test_server/src/ts.unix.config4
-rw-r--r--lib/test_server/src/ts.vxworks.config19
-rw-r--r--lib/test_server/src/ts.win32.config15
-rw-r--r--lib/test_server/src/ts_autoconf_vxworks.erl191
-rw-r--r--lib/test_server/src/ts_autoconf_win32.erl254
-rw-r--r--lib/test_server/src/ts_erl_config.erl398
-rw-r--r--lib/test_server/src/ts_install.erl348
-rw-r--r--lib/test_server/src/ts_lib.erl335
-rw-r--r--lib/test_server/src/ts_make.erl103
-rw-r--r--lib/test_server/src/ts_reports.erl543
-rw-r--r--lib/test_server/src/ts_run.erl746
-rw-r--r--lib/test_server/src/ts_selftest.erl120
-rw-r--r--lib/test_server/src/vxworks_client.erl243
38 files changed, 15242 insertions, 0 deletions
diff --git a/lib/test_server/src/Makefile b/lib/test_server/src/Makefile
new file mode 100644
index 0000000000..2d7e5b28bc
--- /dev/null
+++ b/lib/test_server/src/Makefile
@@ -0,0 +1,145 @@
+#
+# %CopyrightBegin%
+#
+# Copyright Ericsson AB 1996-2009. All Rights Reserved.
+#
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+#
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+#
+# %CopyrightEnd%
+#
+
+include $(ERL_TOP)/make/target.mk
+
+# ----------------------------------------------------
+# Configuration info.
+# ----------------------------------------------------
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+
+# ----------------------------------------------------
+# Application version
+# ----------------------------------------------------
+include ../vsn.mk
+VSN=$(TEST_SERVER_VSN)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/test_server-$(VSN)
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+
+MODULES= test_server_ctrl \
+ test_server_node \
+ test_server \
+ test_server_sup \
+ test_server_line \
+ test_server_h \
+ erl2html2 \
+ vxworks_client
+
+TS_MODULES= \
+ ts \
+ ts_run \
+ ts_reports \
+ ts_lib \
+ ts_make \
+ ts_erl_config \
+ ts_autoconf_win32 \
+ ts_autoconf_vxworks \
+ ts_install
+
+TARGET_MODULES= $(MODULES:%=$(EBIN)/%)
+TS_TARGET_MODULES= $(TS_MODULES:%=$(EBIN)/%)
+
+ERL_FILES= $(MODULES:=.erl)
+TS_ERL_FILES= $(TS_MODULES:=.erl)
+HRL_FILES = ../include/test_server.hrl ../include/test_server_line.hrl
+INTERNAL_HRL_FILES = test_server_internal.hrl
+TS_HRL_FILES= ts.hrl
+C_FILES =
+AUTOCONF_FILES = configure.in conf_vars.in
+COVER_FILES = cross.cover
+PROGRAMS = configure config.sub config.guess install-sh
+CONFIG = ts.config ts.unix.config ts.win32.config ts.vxworks.config
+
+TARGET_FILES = $(MODULES:%=$(EBIN)/%.$(EMULATOR)) \
+ $(APP_TARGET) $(APPUP_TARGET)
+TS_TARGET_FILES = $(TS_MODULES:%=$(EBIN)/%.$(EMULATOR))
+
+TARGETS = $(MODULES:%=$(EBIN)/%.$(EMULATOR)) $(PROGRAMS) \
+ $(APP_TARGET) $(APPUP_TARGET)
+TS_TARGETS = $(TS_MODULES:%=$(EBIN)/%.$(EMULATOR))
+
+APP_FILE= test_server.app
+APP_SRC= $(APP_FILE).src
+APP_TARGET= $(EBIN)/$(APP_FILE)
+
+APPUP_FILE= test_server.appup
+APPUP_SRC= $(APPUP_FILE).src
+APPUP_TARGET= $(EBIN)/$(APPUP_FILE)
+
+# ----------------------------------------------------
+# FLAGS
+# ----------------------------------------------------
+ERL_COMPILE_FLAGS += -I../include
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+tests debug opt: $(TARGETS) $(TS_TARGETS)
+
+clean:
+ rm -f $(TARGET_FILES) $(TS_TARGET_FILES)
+ rm -f core
+
+doc:
+
+configure: configure.in
+ autoconf configure.in > configure
+
+# ----------------------------------------------------
+# Special Build Targets
+# ----------------------------------------------------
+$(APP_TARGET): $(APP_SRC) ../vsn.mk
+ sed -e 's;%VSN%;$(VSN);' $< > $@
+
+$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk
+ sed -e 's;%VSN%;$(VSN);' $< > $@
+
+# ----------------------------------------------------
+# Release Target
+# ----------------------------------------------------
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: opt
+ $(INSTALL_DIR) $(RELSYSDIR)/src
+ $(INSTALL_DATA) $(ERL_FILES) $(RELSYSDIR)/src
+ $(INSTALL_DATA) $(INTERNAL_HRL_FILES) $(RELSYSDIR)/src
+ $(INSTALL_DIR) $(RELSYSDIR)/include
+ $(INSTALL_DATA) $(HRL_FILES) $(RELSYSDIR)/include
+ $(INSTALL_DIR) $(RELSYSDIR)/ebin
+ $(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin
+
+release_tests_spec: opt
+ $(INSTALL_DIR) $(RELEASE_PATH)/test_server
+ $(INSTALL_DATA) $(ERL_FILES) $(TS_ERL_FILES) \
+ $(HRL_FILES) $(INTERNAL_HRL_FILES) $(TS_HRL_FILES) \
+ $(TARGET_FILES) $(TS_TARGET_FILES) \
+ $(AUTOCONF_FILES) $(C_FILES) $(COVER_FILES) $(CONFIG) \
+ $(RELEASE_PATH)/test_server
+ $(INSTALL_PROGRAM) $(PROGRAMS) $(RELEASE_PATH)/test_server
+
+release_docs_spec:
+
diff --git a/lib/test_server/src/conf_vars.in b/lib/test_server/src/conf_vars.in
new file mode 100644
index 0000000000..7c55d7b9ed
--- /dev/null
+++ b/lib/test_server/src/conf_vars.in
@@ -0,0 +1,25 @@
+CC:@CC@
+LD:@LD@
+CFLAGS:@CFLAGS@
+EI_CFLAGS:@EI_CFLAGS@
+ERTS_CFLAGS:@ERTS_CFLAGS@
+CROSSLDFLAGS:@CROSSLDFLAGS@
+SHLIB_LD:@SHLIB_LD@
+SHLIB_LDFLAGS:@SHLIB_LDFLAGS@
+SHLIB_LDLIBS:@SHLIB_LDLIBS@
+SHLIB_CFLAGS:@SHLIB_CFLAGS@
+SHLIB_EXTRACT_ALL:@SHLIB_EXTRACT_ALL@
+dll:@SHLIB_SUFFIX@
+DEFS:@DEFS@
+ERTS_LIBS:@ERTS_LIBS@
+LIBS:@LIBS@
+target_host:@target_host@
+CPU:@host_cpu@
+os:@host_os@
+target:@host@
+obj:@obj@
+exe:@exe@
+SSLEAY_ROOT:@SSLEAY_ROOT@
+JAVAC:@JAVAC@
+make_command:@make_command@
+test_c_compiler:@test_c_compiler@
diff --git a/lib/test_server/src/config.guess b/lib/test_server/src/config.guess
new file mode 120000
index 0000000000..6f1eeddfcc
--- /dev/null
+++ b/lib/test_server/src/config.guess
@@ -0,0 +1 @@
+../../../erts/autoconf/config.guess \ No newline at end of file
diff --git a/lib/test_server/src/config.sub b/lib/test_server/src/config.sub
new file mode 120000
index 0000000000..47a0f10138
--- /dev/null
+++ b/lib/test_server/src/config.sub
@@ -0,0 +1 @@
+../../../erts/autoconf/config.sub \ No newline at end of file
diff --git a/lib/test_server/src/configure.in b/lib/test_server/src/configure.in
new file mode 100644
index 0000000000..2bbbc18966
--- /dev/null
+++ b/lib/test_server/src/configure.in
@@ -0,0 +1,423 @@
+dnl Process this file with autoconf to produce a configure script for Erlang.
+dnl
+dnl %CopyrightBegin%
+dnl
+dnl Copyright Ericsson AB 1997-2009. All Rights Reserved.
+dnl
+dnl The contents of this file are subject to the Erlang Public License,
+dnl Version 1.1, (the "License"); you may not use this file except in
+dnl compliance with the License. You should have received a copy of the
+dnl Erlang Public License along with this software. If not, it can be
+dnl retrieved online at http://www.erlang.org/.
+dnl
+dnl Software distributed under the License is distributed on an "AS IS"
+dnl basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+dnl the License for the specific language governing rights and limitations
+dnl under the License.
+dnl
+dnl %CopyrightEnd%
+dnl
+
+AC_INIT(conf_vars.in)
+
+AC_CANONICAL_HOST
+
+dnl Checks for programs.
+AC_PROG_CC
+
+DEBUG_FLAGS="-g -DDEBUG"
+if test "$GCC" = yes; then
+ DEBUG_FLAGS="$DEBUG_FLAGS -Wall $CFLAGS"
+fi
+AC_SUBST(DEBUG_FLAGS)
+
+AC_ARG_ENABLE(debug-mode,
+[ --enable-debug-mode enable debug mode],
+[ case "$enableval" in
+ no) ;;
+ *) CFLAGS=$DEBUG_FLAGS ;;
+ esac ], )
+
+AC_CHECK_LIB(m, sin)
+
+#--------------------------------------------------------------------
+# Interactive UNIX requires -linet instead of -lsocket, plus it
+# needs net/errno.h to define the socket-related error codes.
+#--------------------------------------------------------------------
+
+AC_CHECK_LIB(inet, main, [LIBS="$LIBS -linet"])
+AC_CHECK_HEADER(net/errno.h, AC_DEFINE(HAVE_NET_ERRNO_H))
+
+#--------------------------------------------------------------------
+# Linux/tcp.h may be needed for sockopt test in kernel
+#--------------------------------------------------------------------
+
+AC_CHECK_HEADER(linux/tcp.h, AC_DEFINE(HAVE_LINUX_TCP_H))
+AC_MSG_CHECKING(for sane linux/tcp.h)
+AC_TRY_COMPILE([#include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <unistd.h>
+ #include <stdarg.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>
+ #include <sys/wait.h>
+ #include <linux/tcp.h>
+ #include <netinet/in.h>
+ #include <netdb.h>],
+ [return 0;],
+ have_sane_linux_tcp_h=yes,
+ have_sane_linux_tcp_h=no)
+
+if test $have_sane_linux_tcp_h = yes; then
+ AC_DEFINE(HAVE_SANE_LINUX_TCP_H,[1],
+ [Define if we have sane linux/tcp.h])
+ AC_MSG_RESULT(yes)
+else
+ AC_MSG_RESULT(no)
+fi
+
+
+
+#--------------------------------------------------------------------
+# Linux requires sys/socketio.h instead of sys/sockio.h
+#--------------------------------------------------------------------
+AC_CHECK_HEADER(sys/socketio.h, AC_DEFINE(HAVE_SOCKETIO_H))
+
+
+#--------------------------------------------------------------------
+# Misc
+#--------------------------------------------------------------------
+AC_CHECK_HEADER(poll.h, AC_DEFINE(HAVE_POLL_H))
+
+#--------------------------------------------------------------------
+# The statements below define a collection of symbols related to
+# dynamic loading and shared libraries:
+#
+# SHLIB_CFLAGS - Flags to pass to cc when compiling the components
+# of a shared library (may request position-independent
+# code, among other things).
+# SHLIB_LD - Base command to use for combining object files
+# into a shared library.
+# SHLIB_SUFFIX - Suffix to use for the names of dynamically loadable
+# extensions. An empty string means we don't know how
+# to use shared libraries on this platform.
+#--------------------------------------------------------------------
+
+# Step 1: set the variable "system" to hold the name and version number
+# for the system.
+
+AC_MSG_CHECKING([system version (for dynamic loading)])
+system=`uname -s`-`uname -r`
+AC_MSG_RESULT($system)
+
+# Step 2: check for existence of -ldl library. This is needed because
+# Linux can use either -ldl or -ldld for dynamic loading.
+
+AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no)
+
+# Step 3: set configuration options based on system name and version.
+
+SHLIB_LDLIBS=
+
+fullSrcDir=`cd $srcdir; pwd`
+case $system in
+ Linux*)
+ SHLIB_CFLAGS="-fPIC"
+ SHLIB_SUFFIX=".so"
+ if test "$have_dl" = yes; then
+ SHLIB_LD="${CC}"
+ SHLIB_LDFLAGS="$LDFLAGS -shared"
+ LD_FLAGS="-rdynamic"
+ else
+ AC_CHECK_HEADER(dld.h, [
+ SHLIB_LD="ld"
+ SHLIB_LDFLAGS="-shared"])
+ fi
+ SHLIB_EXTRACT_ALL=""
+ ;;
+ NetBSD-*|FreeBSD-*|OpenBSD-*)
+ # Not available on all versions: check for include file.
+ AC_CHECK_HEADER(dlfcn.h, [
+ SHLIB_CFLAGS="-fpic"
+ SHLIB_LD="ld"
+ SHLIB_LDFLAGS="$LDFLAGS -Bshareable -x"
+ SHLIB_SUFFIX=".so"
+ ], [
+ # No dynamic loading.
+ SHLIB_CFLAGS=""
+ SHLIB_LD="ld"
+ SHLIB_LDFLAGS="$LDFLAGS"
+ SHLIB_SUFFIX=""
+ AC_MSG_ERROR(don't know how to compile and link dynamic drivers)
+ ])
+ SHLIB_EXTRACT_ALL=""
+ ;;
+ SunOS-4*)
+ SHLIB_CFLAGS="-PIC"
+ SHLIB_LD="ld"
+ SHLIB_LDFLAGS="$LDFLAGS"
+ SHLIB_SUFFIX=".so"
+ SHLIB_EXTRACT_ALL=""
+ ;;
+ SunOS-5*|UNIX_SV-4.2*)
+ SHLIB_CFLAGS="-KPIC"
+ SHLIB_LD="/usr/ccs/bin/ld"
+ SHLIB_LDFLAGS="$LDFLAGS -G -z text"
+ SHLIB_SUFFIX=".so"
+ SHLIB_EXTRACT_ALL="-z allextract"
+ ;;
+ Darwin*)
+ SHLIB_CFLAGS="-fno-common"
+ SHLIB_LD="cc"
+ SHLIB_LDFLAGS="$LDFLAGS -bundle -flat_namespace -undefined suppress"
+ SHLIB_SUFFIX=".so"
+ SHLIB_EXTRACT_ALL=""
+ ;;
+ OSF1*)
+ SHLIB_CFLAGS="-fPIC"
+ SHLIB_LD="ld"
+ SHLIB_LDFLAGS="$LDFLAGS -shared"
+ SHLIB_SUFFIX=".so"
+ SHLIB_EXTRACT_ALL=""
+ ;;
+ *osf5*)
+ SHLIB_CFLAGS="-fPIC"
+ SHLIB_LD="${CC} -shared"
+ SHLIB_LDFLAGS="$LDFLAGS"
+ SHLIB_SUFFIX=".so"
+ SHLIB_EXTRACT_ALL=""
+ ;;
+ *)
+ # No dynamic loading.
+ SHLIB_CFLAGS=""
+ SHLIB_LD="ld"
+ SHLIB_LDFLAGS=""
+ SHLIB_LDLIBS=""
+ SHLIB_SUFFIX=""
+ SHLIB_EXTRACT_ALL=""
+ AC_MSG_ERROR(don't know how to compile and link dynamic drivers)
+ ;;
+esac
+
+# If we're running gcc, then change the C flags for compiling shared
+# libraries to the right flags for gcc, instead of those for the
+# standard manufacturer compiler.
+
+if test "$CC" = "gcc" -o `$CC -v 2>&1 | grep -c gcc` != "0" ; then
+ case $system in
+ AIX-*)
+ ;;
+ BSD/OS*)
+ ;;
+ IRIX*)
+ ;;
+ NetBSD-*|FreeBSD-*|OpenBSD-*)
+ ;;
+ RISCos-*)
+ ;;
+ ULTRIX-4.*)
+ ;;
+ Darwin*)
+ ;;
+ *)
+ SHLIB_CFLAGS="-fPIC"
+ ;;
+ esac
+fi
+
+# Make it possible for erl_interface to use it's own compiler options
+EI_CFLAGS="$CFLAGS"
+
+# Add thread-safety flags if requested
+AC_ARG_ENABLE(shlib-thread-safety,
+[ --enable-shlib-thread-safety enable thread safety for build shared libraries],
+[ case "$enableval" in
+ no) ;;
+ *) SHLIB_CFLAGS="$SHLIB_CFLAGS -D_THREAD_SAFE -D_REENTRANT"
+ CFLAGS="$CFLAGS -D_THREAD_SAFE -D_REENTRANT"
+ ;;
+ esac ], )
+
+SHLIB_CFLAGS="$SHLIB_CFLAGS $CFLAGS"
+
+
+AC_SUBST(CFLAGS)
+AC_SUBST(SHLIB_LD)
+AC_SUBST(SHLIB_LDFLAGS)
+AC_SUBST(SHLIB_LDLIBS)
+AC_SUBST(SHLIB_CFLAGS)
+AC_SUBST(SHLIB_SUFFIX)
+AC_SUBST(SHLIB_EXTRACT_ALL)
+AC_SUBST(EI_CFLAGS)
+
+#--------------------------------------------------------------------
+# Check for the existence of the -lsocket and -lnsl libraries.
+# The order here is important, so that they end up in the right
+# order in the command line generated by make. Here are some
+# special considerations:
+# 1. Use "connect" and "accept" to check for -lsocket, and
+# "gethostbyname" to check for -lnsl.
+# 2. Use each function name only once: can't redo a check because
+# autoconf caches the results of the last check and won't redo it.
+# 3. Use -lnsl and -lsocket only if they supply procedures that
+# aren't already present in the normal libraries. This is because
+# IRIX 5.2 has libraries, but they aren't needed and they're
+# bogus: they goof up name resolution if used.
+# 4. On some SVR4 systems, can't use -lsocket without -lnsl too.
+# To get around this problem, check for both libraries together
+# if -lsocket doesn't work by itself.
+#--------------------------------------------------------------------
+
+erl_checkBoth=0
+AC_CHECK_FUNC(connect, erl_checkSocket=0, erl_checkSocket=1)
+if test "$erl_checkSocket" = 1; then
+ AC_CHECK_LIB(socket, main, LIBS="$LIBS -lsocket", erl_checkBoth=1)
+fi
+if test "$erl_checkBoth" = 1; then
+ tk_oldLibs=$LIBS
+ LIBS="$LIBS -lsocket -lnsl"
+ AC_CHECK_FUNC(accept, erl_checkNsl=0, [LIBS=$tk_oldLibs])
+fi
+AC_CHECK_FUNC(gethostbyname, , AC_CHECK_LIB(nsl, main, [LIBS="$LIBS -lnsl"]))
+
+dnl Checks for library functions.
+AC_CHECK_FUNCS(strerror)
+AC_CHECK_FUNCS(vsnprintf)
+
+# First check if the library is available, then if we can choose between
+# two versions of gethostbyname
+AC_HAVE_LIBRARY(resolv)
+AC_CHECK_LIB(resolv, res_gethostbyname,[DEFS="$DEFS -DHAVE_RES_GETHOSTBYNAME=1"])
+
+#--------------------------------------------------------------------
+# Emulator compatible flags (for drivers)
+#--------------------------------------------------------------------
+
+ERTS_CFLAGS=$CFLAGS
+AC_SUBST(ERTS_CFLAGS)
+
+ERTS_LIBS=$LIBS
+AC_SUBST(ERTS_LIBS)
+
+#--------------------------------------------------------------------
+# Special compiler macro to handle cross compiling
+# (HCC) is used to compile tools run in the HOST environment
+#--------------------------------------------------------------------
+HCC='$(CC)'
+AC_SUBST(HCC)
+
+#--------------------------------------------------------------------
+# ld is used for linking on vxworks
+#--------------------------------------------------------------------
+LD='$(CC) $(CFLAGS)'
+AC_SUBST(LD)
+
+#--------------------------------------------------------------------
+# object file suffix
+#--------------------------------------------------------------------
+obj='.o'
+AC_SUBST(obj)
+
+#--------------------------------------------------------------------
+# executable file suffix
+#--------------------------------------------------------------------
+exe=''
+AC_SUBST(exe)
+
+#--------------------------------------------------------------------
+# flags when linking for cross platform targets (yet 'tis useful with
+# native builds)
+#--------------------------------------------------------------------
+CROSSLDFLAGS=''
+AC_SUBST(CROSSLDFLAGS)
+
+dnl
+dnl SSL and CRYPTO needs the library openSSL/ssleay
+dnl
+dnl Check flags --with-ssl, --without-ssl --with-ssl=PATH.
+dnl If no option is given or --with-ssl is set without a path then we
+dnl search for SSL libraries and header files in the standard locations.
+dnl If set to --without-ssl we disable the use of SSL
+dnl If set to --with-ssl=PATH we use that path as the prefix, i.e. we
+dnl use "PATH/include" and "PATH/lib".
+
+AC_SUBST(SSLEAY_ROOT)
+TARGET=$host
+
+# We search for SSL. First in the OTP team ClearCase standard location,
+# then in the common OS standard locations
+# No we do not.
+SSL_APP=ssl
+CRYPTO_APP=crypto
+SSLEAY_ROOT=$TARGET
+#for dir in /usr /usr/pkg /usr/local /usr/local/ssl /usr/lib/ssl /usr/ssl; do
+# AC_CHECK_HEADER($dir/include/openssl/opensslv.h,
+# ac_cv_openssl=yes, ac_cv_openssl=no)
+# if test $ac_cv_openssl = yes ; then
+# SSLEAY_ROOT="$dir"
+# ssl_found=yes
+# break
+# fi
+#done
+
+# Find a usable java compiler
+#
+# WARNING this code is copied from ERTS configure.in, and should be
+# updated if that code changes. I hate duplicating code, but what
+# can I do.
+#
+dnl ERL_TRY_LINK_JAVA(CLASSES, FUNCTION-BODY
+dnl [ACTION_IF_FOUND [, ACTION-IF-NOT-FOUND]])
+dnl Freely inspired by AC_TRY_LINK. (Maybe better to create a
+dnl AC_LANG_JAVA instead...)
+AC_DEFUN(ERL_TRY_LINK_JAVA,
+[java_link='$JAVAC conftest.java 1>&AC_FD_CC'
+changequote(�, �)dnl
+cat > conftest.java <<EOF
+�$1�
+class conftest { public static void main(String[] args) {
+ �$2�
+ ; return; }}
+EOF
+changequote([, ])dnl
+if AC_TRY_EVAL(java_link) && test -s conftest.class; then
+ ifelse([$3], , :, [rm -rf conftest*
+ $3])
+else
+ echo "configure: failed program was:" 1>&AC_FD_CC
+ cat conftest.java 1>&AC_FD_CC
+ echo "configure: PATH was $PATH" 1>&AC_FD_CC
+ifelse([$4], , , [ rm -rf conftest*
+ $4
+])dnl
+fi
+rm -f conftest*])
+dnl
+AC_CHECK_PROGS(JAVAC, javac guavac gcj jikes bock)
+if test -n "$JAVAC"; then
+ dnl Make sure it's at least JDK 1.5
+ AC_CACHE_CHECK(for JDK version 1.5,
+ ac_cv_prog_javac_ver_1_5,
+ [ERL_TRY_LINK_JAVA([], [for (String i : args);],
+ ac_cv_prog_javac_ver_1_5=yes, ac_cv_prog_javac_ver_1_5=no)])
+ if test $ac_cv_prog_javac_ver_1_5 = no; then
+ unset -v JAVAC
+ fi
+fi
+if test -n "$JAVAC"; then
+ AC_SUBST(JAVAC)
+ :
+fi
+
+AC_CHECK_PROGS([make_command], [make gmake], [false])
+AC_SUBST(make_command)
+
+if test "$GCC" = yes; then
+ test_c_compiler="{gnuc, undefined}"
+else
+ test_c_compiler="undefined"
+fi
+AC_SUBST(test_c_compiler)
+
+AC_OUTPUT(conf_vars)
diff --git a/lib/test_server/src/cross.cover b/lib/test_server/src/cross.cover
new file mode 100644
index 0000000000..07bf0bed5c
--- /dev/null
+++ b/lib/test_server/src/cross.cover
@@ -0,0 +1,20 @@
+%%% This is an -*- erlang -*- file.
+%%%
+%%% Elements in this file shall be on the form
+%%% {Application,Modules}.
+%%%
+%%% Application is the name of an application or the atom all.
+%%% Modules is a list of module names
+%%%
+%%% The Application shall include the listed Modules in its cover compilation,
+%%% but not in the cover analysis.
+%%% If Application=all it means that all application shall include the listed
+%%% Modules in the cover compilation.
+%%%
+%%% After all tests are completed, the listed modules are analysed with cover
+%%% data from all tests and the result is stored under the application where
+%%% the modules belong.
+
+{all,[]}.
+
+{observer,[dbg]}.
diff --git a/lib/test_server/src/erl2html2.erl b/lib/test_server/src/erl2html2.erl
new file mode 100644
index 0000000000..c94d4627f9
--- /dev/null
+++ b/lib/test_server/src/erl2html2.erl
@@ -0,0 +1,182 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%%------------------------------------------------------------------
+%%% Purpose:Convert Erlang files to html. (Pretty faaast... :-)
+%%%------------------------------------------------------------------
+
+%--------------------------------------------------------------------
+% Some stats (Sparc5@110Mhz):
+% 4109 lines (erl_parse.erl): 3.00 secs
+% 1847 lines (application_controller.erl): 0.57 secs
+% 3160 lines (test_server.erl): 1.00 secs
+% 1199 lines (ts_estone.erl): 0.35 secs
+%
+% Avg: ~4.5e-4s/line, or ~0.45s/1000 lines, or ~2200 lines/sec.
+%--------------------------------------------------------------------
+
+-module(erl2html2).
+-export([convert/2]).
+
+convert([], _Dest) -> % Fake clause.
+ ok;
+convert(File, Dest) ->
+ case file:read_file(File) of
+ {ok, Bin} ->
+ Code=binary_to_list(Bin),
+ statistics(runtime),
+ %% The generated code uses the BGCOLOR attribute in the
+ %% BODY tag, which wasn't valid until HTML 3.2. Also,
+ %% good HTML should either override all colour attributes
+ %% or none of them -- *never* just a few.
+ %%
+ %% FIXME: The colours should *really* be set with
+ %% stylesheets...
+ Html0
+ = ["<!DOCTYPE HTML PUBLIC "
+ "\"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<html>\n"
+ "<head><title>", File, "</title></head>\n\n"
+ "<body bgcolor=\"white\" text=\"black\""
+ " link=\"blue\" vlink=\"purple\" alink=\"red\">\n"],
+ {Html1, Lines} = root(Code, [], 1),
+ Html = [Html0,
+ "<pre>\n", Html1, "</pre>\n",
+ footer(Lines),"</body>\n</html>\n"],
+ file:write_file(Dest, Html);
+ {error, Reason} ->
+ {error, Reason}
+ end.
+
+root([], Res, Line) ->
+ {Res, Line};
+root([Char0|Code], Res, Line0) ->
+ Char = [Char0],
+ case Char of
+ "-" ->
+ {Match, Line1, NewCode0, AttName} =
+ read_to_char(Line0+1, Code, [], [$(, $.]),
+ {_, Line2, NewCode, Stuff} = read_to_char(Line1, NewCode0, [], $\n),
+ NewRes = [Res,linenum(Line0),"-<b>",AttName,
+ "</b>",Match, Stuff, "\n"],
+ root(NewCode, NewRes, Line2);
+ "%" ->
+ {_, Line, NewCode, Stuff} = read_to_char(Line0+1, Code, [], $\n),
+ NewRes = [Res,linenum(Line0),"<i>%",Stuff,"</i>\n"],
+ root(NewCode, NewRes, Line);
+ "\n" ->
+ root(Code, [Res,linenum(Line0), "\n"], Line0+1);
+ " " ->
+ {_, Line, NewCode, Stuff} = read_to_char(Line0+1, Code, [], $\n),
+ root(NewCode, [Res,linenum(Line0)," ",Stuff, "\n"],
+ Line);
+ "\t" ->
+ {_, Line, NewCode, Stuff} = read_to_char(Line0+1, Code, [], $\n),
+ root(NewCode, [Res,linenum(Line0),"\t",Stuff, "\n"],
+ Line);
+ [Chr|_] when Chr>96, Chr<123 ->
+ %% Assumed to be function/clause start.
+ %% FIXME: This will trivially generate non-unique anchors
+ %% (one for each clause) --- which is illegal HTML.
+ {_, Line1, NewCode0, FName0} = read_to_char(Line0+1, Code, [], $(),
+ {_, Line2, NewCode, Stuff} =
+ read_to_char(Line1,NewCode0, [], $\n),
+ FuncName = [[Chr],FName0],
+ NewRes=[Res,"<a name=",FuncName,">",
+ linenum(Line0),"<b>",FuncName,"</b></a>",
+ "(",Stuff, "\n"],
+ root(NewCode, NewRes, Line2);
+ Chr ->
+ {_, Line, NewCode, Stuff} = read_to_char(Line0+1, Code, [], $\n),
+ root(NewCode, [Res,linenum(Line0),Chr,Stuff, "\n"],
+ Line)
+ end.
+
+read_to_char(Line0, [], Res, _Chr) ->
+ {nomatch, Line0, [], Res};
+read_to_char(Line0, [Char|Code], Res, Chr) ->
+ case Char of
+ Chr -> {Char, Line0, Code, Res};
+ _ when is_list(Chr) ->
+ case lists:member(Char,Chr) of
+ true ->
+ {Char, Line0, Code, Res};
+ false ->
+ {Line,NewCode,NewRes} = maybe_convert(Line0,Code,Res,Char),
+ read_to_char(Line, NewCode, NewRes, Chr)
+ end;
+ _ ->
+ {Line,NewCode,NewRes} = maybe_convert(Line0,Code,Res,Char),
+ read_to_char(Line,NewCode, NewRes, Chr)
+ end.
+
+maybe_convert(Line0,Code,Res,Chr) ->
+ case Chr of
+ %% Quoted stuff should not have the highlighting like normal code
+ %% FIXME: unbalanced quotes (e.g. in comments) will cause trouble with
+ %% highlighting and line numbering in the rest of the module.
+ $" ->
+ {_, Line1, NewCode, Stuff0} = read_to_char(Line0, Code, [], $"),
+ {Line2,Stuff} = add_linenumbers(Line1,lists:flatten(Stuff0),[]),
+ {Line2,NewCode,[Res,$",Stuff,$"]};
+ %% These chars have meaning in HTML, and *must* *not* be
+ %% written as themselves.
+ $& ->
+ {Line0, Code, [Res,"&amp;"]};
+ $< ->
+ {Line0, Code, [Res,"&lt;"]};
+ $> ->
+ {Line0, Code, [Res,"&gt;"]};
+ %% Everything else is simply copied.
+ OtherChr ->
+ {Line0, Code, [Res,OtherChr]}
+ end.
+
+add_linenumbers(Line,[Chr|Chrs],Res) ->
+ case Chr of
+ $\n -> add_linenumbers(Line+1,Chrs,[Res,$\n,linenum(Line)]);
+ _ -> add_linenumbers(Line,Chrs,[Res,Chr])
+ end;
+add_linenumbers(Line,[],Res) ->
+ {Line,Res}.
+
+%% Make nicely indented line numbers.
+linenum(Line) ->
+ Num = integer_to_list(Line),
+ A = case Line rem 10 of
+ 0 -> "<a name=\"" ++ Num ++"\"></a>";
+ _ -> []
+ end,
+ Pred =
+ case length(Num) of
+ Length when Length < 5 ->
+ lists:duplicate(5-Length,$\s);
+ _ ->
+ []
+ end,
+ [A,Pred,integer_to_list(Line),":"].
+
+footer(Lines) ->
+ {_, Time} = statistics(runtime),
+% io:format("Converted ~p lines in ~.2f Seconds.~n",
+% [Lines, Time/1000]),
+ S = "<i>The transformation of this file (~p lines) took ~.2f seconds</i>",
+ F = lists:flatten(io_lib:format(S, [Lines, Time/1000])),
+ ["<hr size=1>",F,"<br>\n"].
diff --git a/lib/test_server/src/install-sh b/lib/test_server/src/install-sh
new file mode 120000
index 0000000000..a859cade7f
--- /dev/null
+++ b/lib/test_server/src/install-sh
@@ -0,0 +1 @@
+../../../erts/autoconf/install-sh \ No newline at end of file
diff --git a/lib/test_server/src/test_server.app.src b/lib/test_server/src/test_server.app.src
new file mode 100644
index 0000000000..af2d4dc2cb
--- /dev/null
+++ b/lib/test_server/src/test_server.app.src
@@ -0,0 +1,36 @@
+% This is an -*- erlang -*- file.
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+
+{application, test_server,
+ [{description, "The OTP Test Server application"},
+ {vsn, "%VSN%"},
+ {modules, [
+ erl2html2,
+ test_server_ctrl,
+ test_server,
+ test_server_h,
+ test_server_line,
+ test_server_node,
+ test_server_sup
+ ]},
+ {registered, [test_server_ctrl,
+ test_server,
+ test_server_break_process]},
+ {applications, [kernel,stdlib]},
+ {env, []}]}.
+
diff --git a/lib/test_server/src/test_server.appup.src b/lib/test_server/src/test_server.appup.src
new file mode 100644
index 0000000000..0fbe5f23f7
--- /dev/null
+++ b/lib/test_server/src/test_server.appup.src
@@ -0,0 +1 @@
+{"%VSN%",[],[]}. \ No newline at end of file
diff --git a/lib/test_server/src/test_server.erl b/lib/test_server/src/test_server.erl
new file mode 100644
index 0000000000..99e24205ae
--- /dev/null
+++ b/lib/test_server/src/test_server.erl
@@ -0,0 +1,2203 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(test_server).
+
+-define(DEFAULT_TIMETRAP_SECS, 60).
+
+%%% START %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([start/1,start/2]).
+
+%%% TEST_SERVER_CTRL INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([run_test_case_apply/1,init_target_info/0,init_purify/0]).
+-export([cover_compile/1,cover_analyse/2]).
+
+%%% TEST_SERVER_SUP INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([get_loc/1]).
+
+%%% TEST SUITE INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([lookup_config/2]).
+-export([fail/0,fail/1,format/1,format/2,format/3]).
+-export([capture_start/0,capture_stop/0,capture_get/0]).
+-export([messages_get/0]).
+-export([hours/1,minutes/1,seconds/1,sleep/1,timecall/3]).
+-export([timetrap_scale_factor/0,timetrap/1,timetrap_cancel/1]).
+-export([m_out_of_n/3,do_times/4,do_times/2]).
+-export([call_crash/3,call_crash/4,call_crash/5]).
+-export([temp_name/1]).
+-export([start_node/3, stop_node/1, wait_for_node/1, is_release_available/1]).
+-export([app_test/1, app_test/2]).
+-export([is_native/1]).
+-export([comment/1]).
+-export([os_type/0]).
+-export([run_on_shielded_node/2]).
+-export([is_cover/0,is_debug/0,is_commercial/0]).
+
+-export([break/1,continue/0]).
+
+%%% DEBUGGER INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([purify_new_leaks/0, purify_format/2, purify_new_fds_inuse/0,
+ purify_is_running/0]).
+
+%%% PRIVATE EXPORTED %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-record(state,{controller,jobs=[]}).
+
+-include("test_server_internal.hrl").
+-include_lib("kernel/include/file.hrl").
+
+-define(pl2a(M), test_server_sup:package_atom(M)).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% **** START *** CODE FOR REMOTE TARGET ONLY ***
+%%
+%% test_server
+%% This process is started only if the test is to be run on a remote target
+%% The process is then started on target
+%% A socket connection is established with the test_server_ctrl process
+%% on host, and information about target is sent to host.
+start([ControllerHost]) when is_atom(ControllerHost) ->
+ start(atom_to_list(ControllerHost));
+start(ControllerHost) when is_list(ControllerHost) ->
+ start(ControllerHost,?MAIN_PORT).
+start(ControllerHost,ControllerPort) ->
+ S = self(),
+ Pid = spawn(fun() -> init(ControllerHost,ControllerPort,S) end),
+ receive {Pid,started} -> {ok,Pid};
+ {Pid,Error} -> Error
+ end.
+
+init(Host,Port,Starter) ->
+ global:register_name(?MODULE,self()),
+ process_flag(trap_exit,true),
+ test_server_sup:cleanup_crash_dumps(),
+ case gen_tcp:connect(Host,Port, [binary,
+ {reuseaddr,true},
+ {packet,2}]) of
+ {ok,MainSock} ->
+ Starter ! {self(),started},
+ request(MainSock,{target_info,init_target_info()}),
+ loop(#state{controller={Host,MainSock}});
+ Error ->
+ Starter ! {self(),{error,
+ {could_not_contact_controller,Error}}}
+ end.
+
+init_target_info() ->
+ [$.|Emu] = code:objfile_extension(),
+ {_, OTPRel} = init:script_id(),
+ TestServerDir = filename:absname(filename:dirname(code:which(?MODULE))),
+ #target_info{os_family=test_server_sup:get_os_family(),
+ os_type=os:type(),
+ version=erlang:system_info(version),
+ system_version=erlang:system_info(system_version),
+ root_dir=code:root_dir(),
+ test_server_dir=TestServerDir,
+ emulator=Emu,
+ otp_release=OTPRel,
+ username=test_server_sup:get_username(),
+ cookie=atom_to_list(erlang:get_cookie())}.
+
+
+loop(#state{controller={_,MainSock}} = State) ->
+ receive
+ {tcp, MainSock, <<1,Request/binary>>} ->
+ State1 = decode_main(binary_to_term(Request),State),
+ loop(State1);
+ {tcp_closed, MainSock} ->
+ gen_tcp:close(MainSock),
+ halt();
+ {'EXIT',Pid,Reason} ->
+ case lists:keysearch(Pid,1,State#state.jobs) of
+ {value,{Pid,Name}} ->
+ case Reason of
+ normal -> ignore;
+ _other -> request(MainSock,{job_proc_killed,Name,Reason})
+ end,
+ NewJobs = lists:keydelete(Pid,1,State#state.jobs),
+ loop(State#state{jobs = NewJobs});
+ false ->
+ loop(State)
+ end
+ end.
+
+%% Decode request on main socket
+decode_main({job,Port,Name},#state{controller={Host,_},jobs=Jobs}=State) ->
+ S = self(),
+ NewJob = spawn_link(fun() -> job(Host,Port,S) end),
+ receive {NewJob,started} -> State#state{jobs=[{NewJob,Name}|Jobs]};
+ {NewJob,_Error} -> State
+ end.
+
+init_purify() ->
+ purify_new_leaks().
+
+
+%% Temporary job process on target
+%% This process will live while all test cases in the job are executed.
+%% A socket connection is established with the job process on host.
+job(Host,Port,Starter) ->
+ process_flag(trap_exit,true),
+ init_purify(),
+ case gen_tcp:connect(Host,Port, [binary,
+ {reuseaddr,true},
+ {packet,4},
+ {active,false}]) of
+ {ok,JobSock} ->
+ Starter ! {self(),started},
+ job(JobSock);
+ Error ->
+ Starter ! {self(),{error,
+ {could_not_contact_controller,Error}}}
+ end.
+
+job(JobSock) ->
+ JobDir = get_jobdir(),
+ ok = file:make_dir(JobDir),
+ ok = file:make_dir(filename:join(JobDir,?priv_dir)),
+ put(test_server_job_sock,JobSock),
+ put(test_server_job_dir,JobDir),
+ {ok,Cwd} = file:get_cwd(),
+ job_loop(JobSock),
+ ok = file:set_cwd(Cwd),
+ send_privdir(JobDir,JobSock), % also recursively removes jobdir
+ ok.
+
+
+get_jobdir() ->
+ Now = now(),
+ {{Y,M,D},{H,Mi,S}} = calendar:now_to_local_time(Now),
+ Basename = io_lib:format("~w-~2.2.0w-~2.2.0w_~2.2.0w.~2.2.0w.~2.2.0w_~w",
+ [Y,M,D,H,Mi,S,element(3,Now)]),
+ %% if target has a file master, don't use prim_file to look up cwd
+ case lists:keymember(master,1,init:get_arguments()) of
+ true ->
+ {ok,Cwd} = file:get_cwd(),
+ Cwd ++ "/" ++ Basename;
+ false ->
+ filename:absname(Basename)
+ end.
+
+send_privdir(JobDir,JobSock) ->
+ LocalPrivDir = filename:join(JobDir,?priv_dir),
+ case file:list_dir(LocalPrivDir) of
+ {ok,List} when List/=[] ->
+ Tarfile0 = ?priv_dir ++ ".tar.gz",
+ Tarfile = filename:join(JobDir,Tarfile0),
+ {ok,Tar} = erl_tar:open(Tarfile,[write,compressed,cooked]),
+ ok = erl_tar:add(Tar,LocalPrivDir,?priv_dir,[]),
+ ok = erl_tar:close(Tar),
+ {ok,TarBin} = file:read_file(Tarfile),
+ file:delete(Tarfile),
+ ok = del_dir(JobDir),
+ request(JobSock,{{privdir,Tarfile0},TarBin});
+ _ ->
+ ok = del_dir(JobDir),
+ request(JobSock,{privdir,empty_priv_dir})
+ end.
+
+del_dir(Dir) ->
+ case file:read_file_info(Dir) of
+ {ok,#file_info{type=directory}} ->
+ {ok,Cont} = file:list_dir(Dir),
+ lists:foreach(fun(F) -> del_dir(filename:join(Dir,F)) end, Cont),
+ ok = file:del_dir(Dir);
+ {ok,#file_info{}} ->
+ ok = file:delete(Dir);
+ _r ->
+ %% This might be a symlink - let's try to delete it!
+ catch file:delete(Dir),
+ ok
+ end.
+
+%%
+%% Receive and decode request on job socket
+%%
+job_loop(JobSock) ->
+ Request = recv(JobSock),
+ case decode_job(Request) of
+ ok -> job_loop(JobSock);
+ {stop,R} -> R
+ end.
+
+decode_job({{beam,Mod,Which},Beam}) ->
+ % FIXME, shared directory structure on host and target required,
+ % "Library beams" are not loaded from HOST... /Patrik
+ code:add_patha(filename:dirname(Which)),
+ % End of Patriks uglyness...
+ {module,Mod} = code:load_binary(Mod,Which,Beam),
+ ok;
+decode_job({{datadir,Tarfile0},Archive}) ->
+ JobDir = get(test_server_job_dir),
+ Tarfile = filename:join(JobDir,Tarfile0),
+ ok = file:write_file(Tarfile,Archive),
+ % Cooked is temporary removed/broken
+ % ok = erl_tar:extract(Tarfile,[compressed,{cwd,JobDir},cooked]),
+ ok = erl_tar:extract(Tarfile,[compressed,{cwd,JobDir}]),
+ ok = file:delete(Tarfile),
+ ok;
+decode_job({test_case,Case}) ->
+ Result = run_test_case_apply(Case),
+ JobSock = get(test_server_job_sock),
+ request(JobSock,{test_case_result,Result}),
+ case test_server_sup:tar_crash_dumps() of
+ {error,no_crash_dumps} -> request(JobSock,{crash_dumps,no_crash_dumps});
+ {ok,TarFile} ->
+ {ok,TarBin} = file:read_file(TarFile),
+ file:delete(TarFile),
+ request(JobSock,{{crash_dumps,filename:basename(TarFile)},TarBin})
+ end,
+ ok;
+decode_job({sync_apply,{M,F,A}}) ->
+ R = apply(M,F,A),
+ request(get(test_server_job_sock),{sync_result,R}),
+ ok;
+decode_job(job_done) ->
+ {stop,stopped}.
+
+%%
+%% **** STOP *** CODE FOR REMOTE TARGET ONLY ***
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% cover_compile({App,Include,Exclude,Cross}) ->
+%% {ok,AnalyseModules} | {error,Reason}
+%%
+%% App = atom() , name of application to be compiled
+%% Exclude = [atom()], list of modules to exclude
+%% Include = [atom()], list of modules outside of App that should be included
+%% in the cover compilation
+%% Cross = [atoms()], list of modules outside of App shat should be included
+%% in the cover compilation, but that shall not be part of
+%% the cover analysis for this application.
+%%
+%% Cover compile the given application. Return {ok,AnalyseMods} if application
+%% is found, else {error,application_not_found}.
+
+cover_compile({none,_Exclude,Include,Cross}) ->
+ CompileMods = Include++Cross,
+ case length(CompileMods) of
+ 0 ->
+ io:fwrite("WARNING: No modules to cover compile!\n\n",[]),
+ cover:start(), % start cover server anyway
+ {ok,[]};
+ N ->
+ io:fwrite("Cover compiling ~w modules - "
+ "this may take some time... ",[N]),
+ do_cover_compile(CompileMods),
+ io:fwrite("done\n\n",[]),
+ {ok,Include}
+ end;
+cover_compile({App,all,Include,Cross}) ->
+ CompileMods = Include++Cross,
+ case length(CompileMods) of
+ 0 ->
+ io:fwrite("WARNING: No modules to cover compile!\n\n",[]),
+ cover:start(), % start cover server anyway
+ {ok,[]};
+ N ->
+ io:fwrite("Cover compiling '~w' (~w files) - "
+ "this may take some time... ",[App,N]),
+ io:format("\nWARNING: All modules in \'~w\' are excluded\n"
+ "Only cover compiling modules in include list "
+ "and the modules\nin the cross cover file:\n"
+ "~p\n", [App,CompileMods]),
+ do_cover_compile(CompileMods),
+ io:fwrite("done\n\n",[]),
+ {ok,Include}
+ end;
+cover_compile({App,Exclude,Include,Cross}) ->
+ case code:lib_dir(App) of
+ {error,bad_name} ->
+ case Include++Cross of
+ [] ->
+ io:format("\nWARNING: Can't find lib_dir for \'~w\'\n"
+ "Not cover compiling!\n\n",[App]),
+ {error,application_not_found};
+ CompileMods ->
+ io:fwrite("Cover compiling '~w' (~w files) - "
+ "this may take some time... ",
+ [App,length(CompileMods)]),
+ io:format("\nWARNING: Can't find lib_dir for \'~w\'\n"
+ "Only cover compiling modules in include list: "
+ "~p\n", [App,Include]),
+ do_cover_compile(CompileMods),
+ io:fwrite("done\n\n",[]),
+ {ok,Include}
+ end;
+ LibDir ->
+ EbinDir = filename:join([LibDir,"ebin"]),
+ WC = filename:join(EbinDir,"*.beam"),
+ AllMods = module_names(filelib:wildcard(WC)),
+ AnalyseMods = (AllMods ++ Include) -- Exclude,
+ CompileMods = AnalyseMods ++ Cross,
+ case length(CompileMods) of
+ 0 ->
+ io:fwrite("WARNING: No modules to cover compile!\n\n",[]),
+ cover:start(), % start cover server anyway
+ {ok,[]};
+ N ->
+ io:fwrite("Cover compiling '~w' (~w files) - "
+ "this may take some time... ",[App,N]),
+ do_cover_compile(CompileMods),
+ io:fwrite("done\n\n",[]),
+ {ok,AnalyseMods}
+ end
+ end.
+
+
+module_names(Beams) ->
+ [list_to_atom(filename:basename(filename:rootname(Beam))) || Beam <- Beams].
+
+
+do_cover_compile(Modules) ->
+ do_cover_compile1(lists:usort(Modules)). % remove duplicates
+
+do_cover_compile1([Dont|Rest]) when Dont=:=cover;
+ Dont=:=test_server;
+ Dont=:=test_server_ctrl ->
+ do_cover_compile1(Rest);
+do_cover_compile1([M|Rest]) ->
+ case {code:is_sticky(M),code:is_loaded(M)} of
+ {true,_} ->
+ code:unstick_mod(M),
+ case cover:compile_beam(M) of
+ {ok,_} ->
+ ok;
+ Error ->
+ io:fwrite("\nWARNING: Could not cover compile ~w: ~p\n",
+ [M,Error])
+ end,
+ code:stick_mod(M),
+ do_cover_compile1(Rest);
+ {false,false} ->
+ case code:load_file(M) of
+ {module,_} ->
+ do_cover_compile1([M|Rest]);
+ Error ->
+ io:fwrite("\nWARNING: Could not load ~w: ~p\n",[M,Error]),
+ do_cover_compile1(Rest)
+ end;
+ {false,_} ->
+ case cover:compile_beam(M) of
+ {ok,_} ->
+ ok;
+ Error ->
+ io:fwrite("\nWARNING: Could not cover compile ~w: ~p\n",
+ [M,Error])
+ end,
+ do_cover_compile1(Rest)
+ end;
+do_cover_compile1([]) ->
+ ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% cover_analyse(Analyse,Modules) -> [{M,{Cov,NotCov,Details}}]
+%%
+%% Analyse = {details,Dir} | details | {overview,void()} | overview
+%% Modules = [atom()], the modules to analyse
+%%
+%% Cover analysis. If this is a remote target, analyse_to_file can not be used.
+%% In that case the analyse level 'line' is used instead if Analyse==details.
+%%
+%% If this is a local target, the test directory is given
+%% (Analyse=={details,Dir}) and analyse_to_file can be used directly.
+%%
+%% If Analyse==overview | {overview,Dir} analyse_to_file is not used, only
+%% an overview containing the number of covered/not covered lines in each module.
+%%
+%% Also, if a Dir exists, cover data will be exported to a file called
+%% all.coverdata in that directory.
+cover_analyse(Analyse,Modules) ->
+ io:fwrite("Cover analysing...\n",[]),
+ DetailsFun =
+ case Analyse of
+ {details,Dir} ->
+ case cover:export(filename:join(Dir,"all.coverdata")) of
+ ok ->
+ fun(M) ->
+ OutFile = filename:join(Dir,
+ atom_to_list(M) ++
+ ".COVER.html"),
+ case cover:analyse_to_file(M,OutFile,[html]) of
+ {ok,_} ->
+ {file,OutFile};
+ Error ->
+ Error
+ end
+ end;
+ Error ->
+ fun(_) -> Error end
+ end;
+ details ->
+ fun(M) ->
+ case cover:analyse(M,line) of
+ {ok,Lines} ->
+ {lines,Lines};
+ Error ->
+ Error
+ end
+ end;
+ {overview,Dir} ->
+ case cover:export(filename:join(Dir,"all.coverdata")) of
+ ok ->
+ fun(_) -> undefined end;
+ Error ->
+ fun(_) -> Error end
+ end;
+ overview ->
+ fun(_) -> undefined end
+ end,
+ R = lists:map(
+ fun(M) ->
+ case cover:analyse(M,module) of
+ {ok,{M,{Cov,NotCov}}} ->
+ {M,{Cov,NotCov,DetailsFun(M)}};
+ Err ->
+ io:fwrite("WARNING: Analysis failed for ~w. Reason: ~p\n",
+ [M,Err]),
+ {M,Err}
+ end
+ end, Modules),
+ Sticky = unstick_all_sticky(node()),
+ cover:stop(),
+ stick_all_sticky(node(),Sticky),
+ R.
+
+
+unstick_all_sticky(Node) ->
+ lists:filter(
+ fun(M) ->
+ case code:is_sticky(M) of
+ true ->
+ rpc:call(Node,code,unstick_mod,[M]),
+ true;
+ false ->
+ false
+ end
+ end,
+ cover:modules()).
+
+stick_all_sticky(Node,Sticky) ->
+ lists:foreach(
+ fun(M) ->
+ rpc:call(Node,code,stick_mod,[M])
+ end,
+ Sticky).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% run_test_case_apply(Mod,Func,Args,Name,RunInit,MultiplyTimetrap) ->
+%% {Time,Value,Loc,Opts,Comment} | {died,Reason,unknown,Comment}
+%%
+%% Time = float() (seconds)
+%% Value = term()
+%% Loc = term()
+%% Comment = string()
+%% Reason = term()
+%%
+%% Spawns off a process (case process) that actually runs the test suite.
+%% The case process will have the job process as group leader, which makes
+%% it possible to capture all it's output from io:format/2, etc.
+%%
+%% The job process then sits down and waits for news from the case process.
+%% This might be io requests (which are redirected to the log files).
+%%
+%% Returns a tuple with the time spent (in seconds) in the test case,
+%% the return value from the test case or an {'EXIT',Reason} if the case
+%% failed, Loc points out where the test case crashed (if it did). Loc
+%% is either the name of the function, or {<Module>,<Line>} of the last
+%% line executed that had a ?line macro. If the test case did execute
+%% erase/0 or similar, it may be empty. Comment is the last comment added
+%% by test_server:comment/1, the reason if test_server:fail has been
+%% called or the comment given by the return value {comment,Comment} from
+%% a test case.
+%%
+%% {died,Reason,unknown,Comment} is returned if the test case was killed
+%% by some other process. Reason is the kill reason provided.
+%%
+%% MultiplyTimetrap indicates a possible extension of all timetraps
+%% Timetraps will be multiplied by this integer. If it is infinity, no
+%% timetraps will be started at all.
+
+run_test_case_apply({CaseNum,Mod,Func,Args,Name,RunInit,MultiplyTimetrap}) ->
+ purify_format("Test case #~w ~w:~w/1", [CaseNum, Mod, Func]),
+ case os:getenv("TS_RUN_VALGRIND") of
+ false ->
+ ok;
+ _ ->
+ os:putenv("VALGRIND_LOGFILE_INFIX",atom_to_list(Mod)++"."++
+ atom_to_list(Func)++"-")
+ end,
+ test_server_h:testcase({Mod,Func,1}),
+ ProcBef = erlang:system_info(process_count),
+ Result = run_test_case_apply(Mod, Func, Args, Name, RunInit, MultiplyTimetrap),
+ ProcAft = erlang:system_info(process_count),
+ purify_new_leaks(),
+ DetFail = get(test_server_detected_fail),
+ {Result,DetFail,ProcBef,ProcAft}.
+
+run_test_case_apply(Mod, Func, Args, Name, RunInit, MultiplyTimetrap) ->
+ case get(test_server_job_dir) of
+ undefined ->
+ %% i'm a local target
+ do_run_test_case_apply(Mod, Func, Args, Name, RunInit, MultiplyTimetrap);
+ JobDir ->
+ %% i'm a remote target
+ case Args of
+ [Config] when is_list(Config) ->
+ {value,{data_dir,HostDataDir}} =
+ lists:keysearch(data_dir, 1, Config),
+ DataBase = filename:basename(HostDataDir),
+ TargetDataDir = filename:join(JobDir, DataBase),
+ Config1 = lists:keyreplace(data_dir, 1, Config,
+ {data_dir,TargetDataDir}),
+ TargetPrivDir = filename:join(JobDir, ?priv_dir),
+ Config2 = lists:keyreplace(priv_dir, 1, Config1,
+ {priv_dir,TargetPrivDir}),
+ do_run_test_case_apply(Mod, Func, [Config2], Name, RunInit,
+ MultiplyTimetrap);
+ _other ->
+ do_run_test_case_apply(Mod, Func, Args, Name, RunInit,
+ MultiplyTimetrap)
+ end
+ end.
+do_run_test_case_apply(Mod, Func, Args, Name, RunInit, MultiplyTimetrap) ->
+ {ok,Cwd} = file:get_cwd(),
+ Args2Print = case Args of
+ [Args1] when is_list(Args1) ->
+ lists:keydelete(tc_group_result, 1, Args1);
+ _ ->
+ Args
+ end,
+ print(minor, "Test case started with:\n~s:~s(~p)\n", [Mod,Func,Args2Print]),
+ print(minor, "Current directory is ~p\n", [Cwd]),
+ print_timestamp(minor,"Started at "),
+ TCCallback = get(test_server_testcase_callback),
+ Ref = make_ref(),
+ OldGLeader = group_leader(),
+ %% Set ourself to group leader for the spawned process
+ group_leader(self(),self()),
+ Pid =
+ spawn_link(
+ fun() ->
+ run_test_case_eval(Mod, Func, Args, Name, Ref,
+ RunInit, MultiplyTimetrap,
+ TCCallback)
+ end),
+ group_leader(OldGLeader, self()),
+ put(test_server_detected_fail, []),
+ run_test_case_msgloop(Ref, Pid, false, false, "").
+
+%% Ugly bug (pre R5A):
+%% If this process (group leader of the test case) terminates before
+%% all messages have been replied back to the io server, the io server
+%% hangs. Fixed by the 20 milli timeout check here, and by using monitor in
+%% io.erl (livrem OCH hangslen mao :)
+%%
+%% A test case is known to have failed if it returns {'EXIT', _} tuple,
+%% or sends a message {failed, File, Line} to it's group_leader
+%%
+run_test_case_msgloop(Ref, Pid, CaptureStdout, Terminate, Comment) ->
+ %% NOTE: Keep job_proxy_msgloop/0 up to date when changes
+ %% are made in this function!
+ {Timeout,ReturnValue} =
+ case Terminate of
+ {true, ReturnVal} ->
+ {20, ReturnVal};
+ false ->
+ {infinity, should_never_appear}
+ end,
+ receive
+ {abort_current_testcase,Reason,From} ->
+ Line = get_loc(Pid),
+ Mon = erlang:monitor(process, Pid),
+ exit(Pid,{testcase_aborted,Reason,Line}),
+ erlang:yield(),
+ From ! {self(),abort_current_testcase,ok},
+ NewComment =
+ receive
+ {'DOWN', Mon, process, Pid, _} ->
+ Comment
+ after 10000 ->
+ %% Pid is probably trapping exits, hit it harder...
+ exit(Pid, kill),
+ %% here's the only place we know Reason, so we save
+ %% it as a comment, potentially replacing user data
+ Error = lists:flatten(io_lib:format("Aborted: ~p",[Reason])),
+ Error1 = lists:flatten([string:strip(S,left) ||
+ S <- string:tokens(Error,[$\n])]),
+ if length(Error1) > 63 ->
+ string:substr(Error1,1,60) ++ "...";
+ true ->
+ Error1
+ end
+ end,
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,NewComment);
+ {io_request,From,ReplyAs,{put_chars,io_lib,Func,[Format,Args]}}
+ when is_list(Format) ->
+ Msg = (catch io_lib:Func(Format,Args)),
+ run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,io_lib,Func,[Format,Args]}}
+ when is_atom(Format) ->
+ Msg = (catch io_lib:Func(Format,Args)),
+ run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,Bytes}} ->
+ run_test_case_msgloop_io(
+ ReplyAs,CaptureStdout,Bytes,From,put_chars),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,unicode,io_lib,Func,[Format,Args]}}
+ when is_list(Format) ->
+ Msg = unicode_to_latin1(catch io_lib:Func(Format,Args)),
+ run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,latin1,io_lib,Func,[Format,Args]}}
+ when is_list(Format) ->
+ Msg = (catch io_lib:Func(Format,Args)),
+ run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,unicode,io_lib,Func,[Format,Args]}}
+ when is_atom(Format) ->
+ Msg = unicode_to_latin1(catch io_lib:Func(Format,Args)),
+ run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,latin1,io_lib,Func,[Format,Args]}}
+ when is_atom(Format) ->
+ Msg = (catch io_lib:Func(Format,Args)),
+ run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,unicode,Bytes}} ->
+ run_test_case_msgloop_io(
+ ReplyAs,CaptureStdout,unicode_to_latin1(Bytes),From,put_chars),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {io_request,From,ReplyAs,{put_chars,latin1,Bytes}} ->
+ run_test_case_msgloop_io(
+ ReplyAs,CaptureStdout,Bytes,From,put_chars),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ IoReq when element(1, IoReq) == io_request ->
+ %% something else, just pass it on
+ group_leader() ! IoReq,
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {structured_io,ClientPid,Msg} ->
+ output(Msg, ClientPid),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {capture,NewCapture} ->
+ run_test_case_msgloop(Ref,Pid,NewCapture,Terminate,Comment);
+ {sync_apply,From,MFA} ->
+ sync_local_or_remote_apply(false,From,MFA),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {sync_apply_proxy,Proxy,From,MFA} ->
+ sync_local_or_remote_apply(Proxy,From,MFA),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {printout,Detail,Format,Args} ->
+ print(Detail,Format,Args),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {comment,NewComment} ->
+ Terminate1 =
+ case Terminate of
+ {true,{Time,Value,Loc,Opts,_OldComment}} ->
+ {true,{Time,Value,mod_loc(Loc),Opts,NewComment}};
+ Other ->
+ Other
+ end,
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate1,NewComment);
+ {'EXIT',Pid,{Ref,Time,Value,Loc,Opts}} ->
+ RetVal = {Time/1000000,Value,mod_loc(Loc),Opts,Comment},
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,{true,RetVal},Comment);
+ {'EXIT',Pid,Reason} ->
+ case Reason of
+ {timetrap_timeout,TVal,Loc} ->
+ %% convert Loc to form that can be formatted
+ Loc1 = mod_loc(Loc),
+ {Mod,Func} = get_mf(Loc1),
+ %% The framework functions mustn't execute on this
+ %% group leader process or io will cause deadlock,
+ %% so we spawn a dedicated process for the operation
+ %% and let the group leader go back to handle io.
+ spawn_fw_call(Mod,Func,Pid,{timetrap_timeout,TVal},
+ Loc1,self(),Comment),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {timetrap_timeout,TVal,Loc,InitOrEnd} ->
+ Loc1 = mod_loc(Loc),
+ {Mod,_Func} = get_mf(Loc1),
+ spawn_fw_call(Mod,InitOrEnd,Pid,{timetrap_timeout,TVal},
+ Loc1,self(),Comment),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ {testcase_aborted,Reason,Loc} ->
+ Loc1 = mod_loc(Loc),
+ {Mod,Func} = get_mf(Loc1),
+ spawn_fw_call(Mod,Func,Pid,{testcase_aborted,Reason},
+ Loc1,self(),Comment),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ killed ->
+ %% result of an exit(TestCase,kill) call, which is the
+ %% only way to abort a testcase process that traps exits
+ %% (see abort_current_testcase)
+ spawn_fw_call(undefined,undefined,Pid,testcase_aborted_or_killed,
+ unknown,self(),Comment),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ _ ->
+ %% the testcase has terminated because of Reason (e.g. an exit
+ %% because a linked process failed)
+ spawn_fw_call(undefined,undefined,Pid,Reason,
+ unknown,self(),Comment),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment)
+ end;
+ {_FwCallPid,fw_notify_done,RetVal} ->
+ %% the framework has been notified, we're finished
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,{true,RetVal},Comment);
+ {'EXIT',_FwCallPid,{fw_notify_done,Func,Error}} ->
+ %% a framework function failed
+ CB = os:getenv("TEST_SERVER_FRAMEWORK"),
+ Loc = case CB of
+ false ->
+ {test_server,Func};
+ _ ->
+ {list_to_atom(CB),Func}
+ end,
+ RetVal = {died,{framework_error,Loc,Error},Loc,"Framework error"},
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,{true,RetVal},Comment);
+ {failed,File,Line} ->
+ put(test_server_detected_fail,
+ [{File, Line}| get(test_server_detected_fail)]),
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ _Other when not is_tuple(_Other) ->
+ %% ignore anything not generated by test server
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment);
+ _Other when element(1, _Other) /= 'EXIT',
+ element(1, _Other) /= started,
+ element(1, _Other) /= finished,
+ element(1, _Other) /= print ->
+ %% ignore anything not generated by test server
+ run_test_case_msgloop(Ref,Pid,CaptureStdout,Terminate,Comment)
+ after Timeout ->
+ ReturnValue
+ end.
+
+run_test_case_msgloop_io(ReplyAs,CaptureStdout,Msg,From,Func) ->
+ case Msg of
+ {'EXIT',_} ->
+ From ! {io_reply,ReplyAs,{error,Func}};
+ _ ->
+ From ! {io_reply,ReplyAs,ok}
+ end,
+ if CaptureStdout /= false ->
+ CaptureStdout ! {captured,Msg};
+ true ->
+ ok
+ end,
+ output({minor,Msg},From).
+
+output(Msg,Sender) ->
+ local_or_remote_apply({test_server_ctrl,output,[Msg,Sender]}).
+
+spawn_fw_call(Mod,{init_per_testcase,Func},Pid,{timetrap_timeout,TVal}=Why,
+ Loc,SendTo,Comment) ->
+ FwCall =
+ fun() ->
+ Skip = {skip,{failed,{Mod,init_per_testcase,Why}}},
+ %% if init_per_testcase fails, the test case
+ %% should be skipped
+ case catch test_server_sup:framework_call(
+ end_tc,[?pl2a(Mod),Func,{Pid,Skip,[[]]}]) of
+ {'EXIT',FwEndTCErr} ->
+ exit({fw_notify_done,end_tc,FwEndTCErr});
+ _ ->
+ ok
+ end,
+ %% finished, report back
+ SendTo ! {self(),fw_notify_done,
+ {TVal/1000,Skip,Loc,[],Comment}}
+ end,
+ spawn_link(FwCall);
+spawn_fw_call(Mod,{end_per_testcase,Func},Pid,{timetrap_timeout,TVal}=Why,
+ Loc,SendTo,_Comment) ->
+ FwCall =
+ fun() ->
+ Conf = [{tc_status,ok}],
+ %% if end_per_testcase fails, the test case should be
+ %% reported successful with a warning printed as comment
+ case catch test_server_sup:framework_call(end_tc,
+ [?pl2a(Mod),Func,
+ {Pid,
+ {failed,{Mod,end_per_testcase,Why}},
+ [Conf]}]) of
+ {'EXIT',FwEndTCErr} ->
+ exit({fw_notify_done,end_tc,FwEndTCErr});
+ _ ->
+ ok
+ end,
+ %% finished, report back
+ SendTo ! {self(),fw_notify_done,
+ {TVal/1000,{error,{Mod,end_per_testcase,Why}},Loc,[],
+ ["<font color=\"red\">"
+ "WARNING: end_per_testcase timed out!"
+ "</font>"]}}
+ end,
+ spawn_link(FwCall);
+spawn_fw_call(Mod,Func,Pid,Error,Loc,SendTo,Comment) ->
+ FwCall =
+ fun() ->
+ case catch fw_error_notify(Mod,Func,[],
+ Error,Loc) of
+ {'EXIT',FwErrorNotifyErr} ->
+ exit({fw_notify_done,error_notification,
+ FwErrorNotifyErr});
+ _ ->
+ ok
+ end,
+ Conf = [{tc_status,{failed,timetrap_timeout}}],
+ case catch test_server_sup:framework_call(end_tc,
+ [?pl2a(Mod),Func,
+ {Pid,Error,[Conf]}]) of
+ {'EXIT',FwEndTCErr} ->
+ exit({fw_notify_done,end_tc,FwEndTCErr});
+ _ ->
+ ok
+ end,
+ %% finished, report back
+ SendTo ! {self(),fw_notify_done,{died,Error,Loc,Comment}}
+ end,
+ spawn_link(FwCall).
+
+%% The job proxy process forwards messages between the test case
+%% process on a shielded node (and its descendants) and the job process.
+%%
+%% The job proxy process have to be started by the test-case process
+%% on the shielded node!
+start_job_proxy() ->
+ group_leader(spawn(fun () -> job_proxy_msgloop() end), self()), ok.
+
+%% The io_reply_proxy is not the most satisfying solution but it works...
+io_reply_proxy(ReplyTo) ->
+ receive
+ IoReply when is_tuple(IoReply),
+ element(1, IoReply) == io_reply ->
+ ReplyTo ! IoReply;
+ _ ->
+ io_reply_proxy(ReplyTo)
+ end.
+
+job_proxy_msgloop() ->
+ receive
+
+ %%
+ %% Messages that need intervention by proxy...
+ %%
+
+ %% io stuff ...
+ IoReq when tuple_size(IoReq) >= 2,
+ element(1, IoReq) == io_request ->
+
+ ReplyProxy = spawn(fun () -> io_reply_proxy(element(2, IoReq)) end),
+ group_leader() ! setelement(2, IoReq, ReplyProxy);
+
+ %% test_server stuff...
+ {sync_apply, From, MFA} ->
+ group_leader() ! {sync_apply_proxy, self(), From, MFA};
+ {sync_result_proxy, To, Result} ->
+ To ! {sync_result, Result};
+
+ %%
+ %% Messages that need no intervention by proxy...
+ %%
+ Msg ->
+ group_leader() ! Msg
+ end,
+ job_proxy_msgloop().
+
+%% A test case is known to have failed if it returns {'EXIT', _} tuple,
+%% or sends a message {failed, File, Line} to it's group_leader
+
+run_test_case_eval(Mod, Func, Args0, Name, Ref, RunInit,
+ MultiplyTimetrap, TCCallback) ->
+ put(test_server_multiply_timetraps,MultiplyTimetrap),
+ {{Time,Value},Loc,Opts} =
+ case test_server_sup:framework_call(init_tc,[?pl2a(Mod),Func,Args0],
+ {ok,Args0}) of
+ {ok,Args} ->
+ run_test_case_eval1(Mod, Func, Args, Name, RunInit, TCCallback);
+ Error = {error,_Reason} ->
+ test_server_sup:framework_call(end_tc,[?pl2a(Mod),Func,{Error,Args0}]),
+ {{0,{skip,{failed,Error}}},{Mod,Func},[]};
+ {fail,Reason} ->
+ [Conf] = Args0,
+ Conf1 = [{tc_status,{failed,Reason}} | Conf],
+ fw_error_notify(Mod, Func, Conf, Reason),
+ test_server_sup:framework_call(end_tc,[?pl2a(Mod),Func,
+ {{error,Reason},[Conf1]}]),
+ {{0,{failed,Reason}},{Mod,Func},[]};
+ Skip = {skip,_Reason} ->
+ test_server_sup:framework_call(end_tc,[?pl2a(Mod),Func,{Skip,Args0}]),
+ {{0,Skip},{Mod,Func},[]};
+ {auto_skip,Reason} ->
+ test_server_sup:framework_call(end_tc,[?pl2a(Mod),
+ Func,
+ {{skip,Reason},Args0}]),
+ {{0,{skip,{fw_auto_skip,Reason}}},{Mod,Func},[]}
+ end,
+ exit({Ref,Time,Value,Loc,Opts}).
+
+run_test_case_eval1(Mod, Func, Args, Name, RunInit, TCCallback) ->
+ case RunInit of
+ run_init ->
+ put(test_server_init_or_end_conf,{init_per_testcase,Func}),
+ put(test_server_loc, {Mod,{init_per_testcase,Func}}),
+ ensure_timetrap(Args),
+ case init_per_testcase(Mod, Func, Args) of
+ Skip = {skip,Reason} ->
+ Line = get_loc(),
+ Conf = [{tc_status,{skipped,Reason}}],
+ test_server_sup:framework_call(end_tc,[?pl2a(Mod),Func,{Skip,[Conf]}]),
+ {{0,{skip,Reason}},Line,[]};
+ {skip_and_save,Reason,SaveCfg} ->
+ Line = get_loc(),
+ Conf = [{tc_status,{skipped,Reason}},{save_config,SaveCfg}],
+ test_server_sup:framework_call(end_tc,[?pl2a(Mod),Func,
+ {{skip,Reason},[Conf]}]),
+ {{0,{skip,Reason}},Line,[]};
+ {ok,NewConf} ->
+ put(test_server_init_or_end_conf,undefined),
+ %% call user callback function if defined
+ NewConf1 = user_callback(TCCallback, Mod, Func, init, NewConf),
+ put(test_server_loc, {Mod,Func}),
+ %% execute the test case
+ {{T,Return},Loc} = {ts_tc(Mod, Func, [NewConf1]),get_loc()},
+ {EndConf,TSReturn,FWReturn} =
+ case Return of
+ {E,TCError} when E=='EXIT' ; E==failed ->
+ fw_error_notify(Mod, Func, NewConf1,
+ TCError, mod_loc(Loc)),
+ {[{tc_status,{failed,TCError}}|NewConf1],
+ Return,{error,TCError}};
+ SaveCfg={save_config,_} ->
+ {[{tc_status,ok},SaveCfg|NewConf1],Return,ok};
+ {skip_and_save,Why,SaveCfg} ->
+ Skip = {skip,Why},
+ {[{tc_status,{skipped,Why}},{save_config,SaveCfg}|NewConf1],
+ Skip,Skip};
+ {skip,Why} ->
+ {[{tc_status,{skipped,Why}}|NewConf1],Return,Return};
+ _ ->
+ {[{tc_status,ok}|NewConf1],Return,ok}
+ end,
+ %% call user callback function if defined
+ EndConf1 = user_callback(TCCallback, Mod, Func, 'end', EndConf),
+ {FWReturn1,TSReturn1,EndConf2} =
+ case end_per_testcase(Mod, Func, EndConf1) of
+ SaveCfg1={save_config,_} ->
+ {FWReturn,TSReturn,[SaveCfg1|lists:keydelete(save_config, 1, EndConf1)]};
+ {fail,ReasonToFail} -> % user has failed the testcase
+ fw_error_notify(Mod, Func, EndConf1, ReasonToFail),
+ {{error,ReasonToFail},{failed,ReasonToFail},EndConf1};
+ {failed,{_,end_per_testcase,_}} = Failure -> % unexpected termination
+ {Failure,TSReturn,EndConf1};
+ _ ->
+ {FWReturn,TSReturn,EndConf1}
+ end,
+ case test_server_sup:framework_call(end_tc, [?pl2a(Mod), Func,
+ {FWReturn1,[EndConf2]}]) of
+ {fail,Reason} ->
+ fw_error_notify(Mod, Func, EndConf2, Reason),
+ {{T,{failed,Reason}},{Mod,Func},[]};
+ _ ->
+ {{T,TSReturn1},Loc,[]}
+ end
+ end;
+ skip_init ->
+ %% call user callback function if defined
+ Args1 = user_callback(TCCallback, Mod, Func, init, Args),
+ ensure_timetrap(Args1),
+ %% ts_tc does a catch
+ put(test_server_loc, {Mod,Func}),
+ %% if this is a named conf group, the test case (init or end conf)
+ %% should be called with the name as the first argument
+ Args2 = if Name == undefined -> Args1;
+ true -> [Name | Args1]
+ end,
+ %% execute the conf test case
+ {{T,Return},Loc} = {ts_tc(Mod, Func, Args2),get_loc()},
+ %% call user callback function if defined
+ Return1 = user_callback(TCCallback, Mod, Func, 'end', Return),
+ {Return2,Opts} = process_return_val([Return1], Mod,Func,Args1, Loc, Return1),
+ {{T,Return2},Loc,Opts}
+ end.
+
+%% the return value is a list and we have to check if it contains
+%% the result of an end conf case or if it's a Config list
+process_return_val([Return], M,F,A, Loc, Final) when is_list(Return) ->
+ ReturnTags = [skip,skip_and_save,save_config,comment,return_group_result],
+ %% check if all elements in the list are valid end conf return value tuples
+ case lists:all(fun(Val) when is_tuple(Val) ->
+ lists:any(fun(T) -> T == element(1, Val) end, ReturnTags);
+ (ok) ->
+ true;
+ (_) ->
+ false
+ end, Return) of
+ true -> % must be return value from end conf case
+ process_return_val1(Return, M,F,A, Loc, Final, []);
+ false -> % must be Config value from init conf case
+ test_server_sup:framework_call(end_tc, [?pl2a(M),F,{ok,A}]),
+ {Return,[]}
+ end;
+%% the return value is not a list, so it's the return value from an
+%% end conf case or it's a dummy value that can be ignored
+process_return_val(Return, M,F,A, Loc, Final) ->
+ process_return_val1(Return, M,F,A, Loc, Final, []).
+
+process_return_val1([Failed={E,TCError}|_], M,F,A=[Args], Loc, _, SaveOpts) when E=='EXIT';
+ E==failed ->
+ fw_error_notify(M,F,A, TCError, mod_loc(Loc)),
+ test_server_sup:framework_call(end_tc,
+ [?pl2a(M),F,{{error,TCError},
+ [[{tc_status,{failed,TCError}}|Args]]}]),
+ {Failed,SaveOpts};
+process_return_val1([SaveCfg={save_config,_}|Opts], M,F,[Args], Loc, Final, SaveOpts) ->
+ process_return_val1(Opts, M,F,[[SaveCfg|Args]], Loc, Final, SaveOpts);
+process_return_val1([{skip_and_save,Why,SaveCfg}|Opts], M,F,[Args], Loc, _, SaveOpts) ->
+ process_return_val1(Opts, M,F,[[{save_config,SaveCfg}|Args]], Loc, {skip,Why}, SaveOpts);
+process_return_val1([GR={return_group_result,_}|Opts], M,F,A, Loc, Final, SaveOpts) ->
+ process_return_val1(Opts, M,F,A, Loc, Final, [GR|SaveOpts]);
+process_return_val1([RetVal={Tag,_}|Opts], M,F,A, Loc, _, SaveOpts) when Tag==skip;
+ Tag==comment ->
+ process_return_val1(Opts, M,F,A, Loc, RetVal, SaveOpts);
+process_return_val1([_|Opts], M,F,A, Loc, Final, SaveOpts) ->
+ process_return_val1(Opts, M,F,A, Loc, Final, SaveOpts);
+process_return_val1([], M,F,A, _Loc, Final, SaveOpts) ->
+ test_server_sup:framework_call(end_tc, [?pl2a(M),F,{Final,A}]),
+ {Final,lists:reverse(SaveOpts)}.
+
+user_callback(undefined, _, _, _, Args) ->
+ Args;
+user_callback({CBMod,CBFunc}, Mod, Func, InitOrEnd, [Args]) when is_list(Args) ->
+ case catch apply(CBMod, CBFunc, [InitOrEnd,Mod,Func,Args]) of
+ Args1 when is_list(Args1) ->
+ [Args1];
+ _ ->
+ [Args]
+ end;
+user_callback({CBMod,CBFunc}, Mod, Func, InitOrEnd, Args) ->
+ case catch apply(CBMod, CBFunc, [InitOrEnd,Mod,Func,Args]) of
+ Args1 when is_list(Args1) ->
+ Args1;
+ _ ->
+ Args
+ end.
+
+init_per_testcase(Mod, Func, Args) ->
+ case code:is_loaded(Mod) of
+ false -> code:load_file(Mod);
+ _ -> ok
+ end,
+ %% init_per_testcase defined, returns new configuration
+ case erlang:function_exported(Mod,init_per_testcase,2) of
+ true ->
+ case catch my_apply(Mod, init_per_testcase, [Func|Args]) of
+ {'$test_server_ok',{Skip,Reason}} when Skip==skip;
+ Skip==skipped ->
+ {skip,Reason};
+ {'$test_server_ok',Res={skip_and_save,_,_}} ->
+ Res;
+ {'$test_server_ok',NewConf} when is_list(NewConf) ->
+ case lists:filter(fun(T) when is_tuple(T) -> false;
+ (_) -> true end, NewConf) of
+ [] ->
+ {ok,NewConf};
+ Bad ->
+ group_leader() ! {printout,12,
+ "ERROR! init_per_testcase has returned "
+ "bad elements in Config: ~p\n",[Bad]},
+ {skip,{failed,{Mod,init_per_testcase,bad_return}}}
+ end;
+ {'$test_server_ok',_Other} ->
+ group_leader() ! {printout,12,
+ "ERROR! init_per_testcase did not return "
+ "a Config list.\n",[]},
+ {skip,{failed,{Mod,init_per_testcase,bad_return}}};
+ {'EXIT',Reason} ->
+ Line = get_loc(),
+ FormattedLoc = test_server_sup:format_loc(mod_loc(Line)),
+ group_leader() ! {printout,12,
+ "ERROR! init_per_testcase crashed!\n"
+ "\tLocation: ~s\n\tReason: ~p\n",
+ [FormattedLoc,Reason]},
+ {skip,{failed,{Mod,init_per_testcase,Reason}}};
+ Other ->
+ Line = get_loc(),
+ FormattedLoc = test_server_sup:format_loc(mod_loc(Line)),
+ group_leader() ! {printout,12,
+ "ERROR! init_per_testcase thrown!\n"
+ "\tLocation: ~s\n\tReason: ~p\n",
+ [FormattedLoc, Other]},
+ {skip,{failed,{Mod,init_per_testcase,Other}}}
+ end;
+ false ->
+ %% Optional init_per_testcase not defined
+ %% keep quiet.
+ [Config] = Args,
+ {ok, Config}
+ end.
+
+end_per_testcase(Mod, Func, Conf) ->
+ case erlang:function_exported(Mod,end_per_testcase,2) of
+ true ->
+ do_end_per_testcase(Mod,end_per_testcase,Func,Conf);
+ false ->
+ %% Backwards compatibility!
+ case erlang:function_exported(Mod,fin_per_testcase,2) of
+ true ->
+ do_end_per_testcase(Mod,fin_per_testcase,Func,Conf);
+ false ->
+ ok
+ end
+ end.
+
+do_end_per_testcase(Mod,EndFunc,Func,Conf) ->
+ put(test_server_init_or_end_conf,{EndFunc,Func}),
+ put(test_server_loc, {Mod,{EndFunc,Func}}),
+ case catch my_apply(Mod, EndFunc, [Func,Conf]) of
+ {'$test_server_ok',SaveCfg={save_config,_}} ->
+ SaveCfg;
+ {'$test_server_ok',{fail,_}=Fail} ->
+ Fail;
+ {'$test_server_ok',_} ->
+ ok;
+ {'EXIT',Reason} = Why ->
+ comment(io_lib:format("<font color=\"red\">"
+ "WARNING: ~w crashed!"
+ "</font>\n",[EndFunc])),
+ group_leader() ! {printout,12,
+ "WARNING: ~w crashed!\n"
+ "Reason: ~p\n"
+ "Line: ~s\n",
+ [EndFunc, Reason,
+ test_server_sup:format_loc(
+ mod_loc(get_loc()))]},
+ {failed,{Mod,end_per_testcase,Why}};
+ Other ->
+ comment(io_lib:format("<font color=\"red\">"
+ "WARNING: ~w thrown!"
+ "</font>\n",[EndFunc])),
+ group_leader() ! {printout,12,
+ "WARNING: ~w thrown!\n"
+ "Reason: ~p\n"
+ "Line: ~s\n",
+ [EndFunc, Other,
+ test_server_sup:format_loc(
+ mod_loc(get_loc()))]},
+ {failed,{Mod,end_per_testcase,Other}}
+ end.
+
+get_loc() ->
+ case catch test_server_line:get_lines() of
+ [] ->
+ get(test_server_loc);
+ {'EXIT',_} ->
+ get(test_server_loc);
+ Loc ->
+ Loc
+ end.
+
+get_loc(Pid) ->
+ {dictionary,Dict} = process_info(Pid, dictionary),
+ lists:foreach(fun({Key,Val}) -> put(Key,Val) end,Dict),
+ get_loc().
+
+get_mf([{M,F,_}|_]) -> {M,F};
+get_mf([{M,F}|_]) -> {M,F};
+get_mf(_) -> {undefined,undefined}.
+
+mod_loc(Loc) ->
+ %% handle diff line num versions
+ case Loc of
+ [{{_M,_F},_L}|_] ->
+ [{?pl2a(M),F,L} || {{M,F},L} <- Loc];
+ [{_M,_F}|_] ->
+ [{?pl2a(M),F} || {M,F} <- Loc];
+ {{M,F},L} ->
+ [{?pl2a(M),F,L}];
+ {M,ForL} ->
+ [{?pl2a(M),ForL}];
+ _ ->
+ Loc
+ end.
+
+
+fw_error_notify(Mod, Func, Args, Error) ->
+ test_server_sup:framework_call(error_notification,
+ [?pl2a(Mod),Func,[Args],
+ {Error,unknown}]).
+fw_error_notify(Mod, Func, Args, Error, Loc) ->
+ test_server_sup:framework_call(error_notification,
+ [?pl2a(Mod),Func,[Args],
+ {Error,Loc}]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% print(Detail,Format,Args) -> ok
+%% Detail = integer()
+%% Format = string()
+%% Args = [term()]
+%%
+%% Just like io:format, except that depending on the Detail value, the output
+%% is directed to console, major and/or minor log files.
+
+print(Detail,Format,Args) ->
+ local_or_remote_apply({test_server_ctrl,print,[Detail,Format,Args]}).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% print_timsteamp(Detail,Leader) -> ok
+%%
+%% Prints Leader followed by a time stamp (date and time). Depending on
+%% the Detail value, the output is directed to console, major and/or minor
+%% log files.
+
+print_timestamp(Detail,Leader) ->
+ local_or_remote_apply({test_server_ctrl,print_timestamp,[Detail,Leader]}).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% lookup_config(Key,Config) -> {value,{Key,Value}} | undefined
+%% Key = term()
+%% Value = term()
+%% Config = [{Key,Value},...]
+%%
+%% Looks up a specific key in the config list, and returns the value
+%% of the associated key, or undefined if the key doesn't exist.
+
+lookup_config(Key,Config) ->
+ case lists:keysearch(Key,1,Config) of
+ {value,{Key,Val}} ->
+ Val;
+ _ ->
+ io:format("Could not find element ~p in Config.~n",[Key]),
+ undefined
+ end.
+
+%% timer:tc/3
+ts_tc(M, F, A) ->
+ Before = erlang:now(),
+ Val = (catch my_apply(M, F, A)),
+ After = erlang:now(),
+ Result = case Val of
+ {'$test_server_ok', R} ->
+ R; % test case ok
+ {'EXIT',_Reason} = R ->
+ R; % test case crashed
+ Other ->
+ {failed, {thrown,Other}} % test case was thrown
+ end,
+ Elapsed =
+ (element(1,After)*1000000000000
+ +element(2,After)*1000000+element(3,After)) -
+ (element(1,Before)*1000000000000
+ +element(2,Before)*1000000+element(3,Before)),
+ {Elapsed, Result}.
+
+my_apply(M, F, A) ->
+ {'$test_server_ok',apply(M, F, A)}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% TEST SUITE SUPPORT FUNCTIONS %%
+%% %%
+%% Note: Some of these functions have been moved to test_server_sup %%
+%% in an attempt to keep this modules small (yeah, right!) %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+unicode_to_latin1(Chars) when is_list(Chars); is_binary(Chars) ->
+ lists:flatten(
+ [ case X of
+ High when High > 255 ->
+ io_lib:format("\\{~.8B}",[X]);
+ Low ->
+ Low
+ end || X <- unicode:characters_to_list(Chars,unicode) ]);
+unicode_to_latin1(Garbage) ->
+ Garbage.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% format(Format) -> IoLibReturn
+%% format(Detail,Format) -> IoLibReturn
+%% format(Format,Args) -> IoLibReturn
+%% format(Detail,Format,Args) -> IoLibReturn
+%% Detail = integer()
+%% Format = string()
+%% Args = [term(),...]
+%% IoLibReturn = term()
+%%
+%% Logs the Format string and Args, similar to io:format/1/2 etc. If
+%% Detail is not specified, the default detail level (which is 50) is used.
+%% Which log files the string will be logged in depends on the thresholds
+%% set with set_levels/3. Typically with default detail level, only the
+%% minor log file is used.
+format(Format) ->
+ format(minor, Format, []).
+
+format(major, Format) ->
+ format(major, Format, []);
+format(minor, Format) ->
+ format(minor, Format, []);
+format(Detail, Format) when is_integer(Detail) ->
+ format(Detail, Format, []);
+format(Format, Args) ->
+ format(minor, Format, Args).
+
+format(Detail, Format, Args) ->
+ Str =
+ case catch io_lib:format(Format,Args) of
+ {'EXIT',_} ->
+ io_lib:format("illegal format; ~p with args ~p.\n",
+ [Format,Args]);
+ Valid -> Valid
+ end,
+ log({Detail, Str}).
+
+log(Msg) ->
+ group_leader() ! {structured_io, self(), Msg},
+ ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% capture_start() -> ok
+%% capture_stop() -> ok
+%%
+%% Starts/stops capturing all output from io:format, and similar. Capturing
+%% output doesn't stop output from happening. It just makes it possible
+%% to retrieve the output using capture_get/0.
+%% Starting and stopping capture doesn't affect already captured output.
+%% All output is stored as messages in the message queue until retrieved
+
+capture_start() ->
+ group_leader() ! {capture,self()},
+ ok.
+
+capture_stop() ->
+ group_leader() ! {capture,false},
+ ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% capture_get() -> Output
+%% Output = [string(),...]
+%%
+%% Retrieves all the captured output since last call to capture_get/0.
+%% Note that since output arrive as messages to the process, it takes
+%% a short while from the call to io:format until all output is available
+%% by capture_get/0. It is not necessary to call capture_stop/0 before
+%% retreiving the output.
+capture_get() ->
+ test_server_sup:capture_get([]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% messages_get() -> Messages
+%% Messages = [term(),...]
+%%
+%% Returns all messages in the message queue.
+messages_get() ->
+ test_server_sup:messages_get([]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% sleep(Time) -> ok
+%% Time = integer() | float() | infinity
+%%
+%% Sleeps the specified number of milliseconds. This sleep also accepts
+%% floating point numbers (which are truncated) and the atom 'infinity'.
+sleep(infinity) ->
+ receive
+ after infinity ->
+ ok
+ end;
+sleep(MSecs) ->
+ receive
+ after trunc(MSecs) ->
+ ok
+ end,
+ ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% fail(Reason) -> exit({suite_failed,Reason})
+%%
+%% Immediately calls exit. Included because test suites are easier
+%% to read when using this function, rather than exit directly.
+fail(Reason) ->
+ comment(cast_to_list(Reason)),
+ exit({suite_failed,Reason}).
+
+cast_to_list(X) when is_list(X) -> X;
+cast_to_list(X) when is_atom(X) -> atom_to_list(X);
+cast_to_list(X) -> lists:flatten(io_lib:format("~p", [X])).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% fail() -> exit(suite_failed)
+%%
+%% Immediately calls exit. Included because test suites are easier
+%% to read when using this function, rather than exit directly.
+fail() ->
+ exit(suite_failed).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% break(Comment) -> ok
+%%
+%% Break a test case so part of the test can be done manually.
+%% Use continue/0 to continue.
+break(Comment) ->
+ case erase(test_server_timetraps) of
+ undefined -> ok;
+ List -> lists:foreach(fun(Ref) -> timetrap_cancel(Ref) end,List)
+ end,
+ io:format(user,
+ "\n\n\n--- SEMIAUTOMATIC TESTING ---"
+ "\nThe test case executes on process ~w"
+ "\n\n\n~s"
+ "\n\n\n-----------------------------\n\n"
+ "Continue with --> test_server:continue().\n",
+ [self(),Comment]),
+ case whereis(test_server_break_process) of
+ undefined ->
+ spawn_break_process(self());
+ OldBreakProcess ->
+ OldBreakProcess ! cancel,
+ spawn_break_process(self())
+ end,
+ receive continue -> ok end.
+
+spawn_break_process(Pid) ->
+ spawn(fun() ->
+ register(test_server_break_process,self()),
+ receive
+ continue -> continue(Pid);
+ cancel -> ok
+ end
+ end).
+
+continue() ->
+ case whereis(test_server_break_process) of
+ undefined ->
+ ok;
+ BreakProcess ->
+ BreakProcess ! continue
+ end.
+
+continue(Pid) ->
+ Pid ! continue.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timetrap_scale_factor() -> Factor
+%%
+%% Returns the amount to scale timetraps with.
+
+timetrap_scale_factor() ->
+ F0 = case test_server:purify_is_running() of
+ true -> 5;
+ false -> 1
+ end,
+ F1 = case {is_debug(), has_lock_checking()} of
+ {true,_} -> 6 * F0;
+ {false,true} -> 2 * F0;
+ {false,false} -> F0
+ end,
+ F2 = case has_superfluous_schedulers() of
+ true -> 3*F1;
+ false -> F1
+ end,
+ F = case test_server_sup:get_os_family() of
+ vxworks -> 5 * F2;
+ _ -> F2
+ end,
+ case test_server:is_cover() of
+ true -> 10 * F;
+ false -> F
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timetrap(Timeout) -> Handle
+%% Handle = term()
+%%
+%% Creates a time trap, that will kill the calling process if the
+%% trap is not cancelled with timetrap_cancel/1, within Timeout milliseconds.
+
+timetrap(Timeout0) ->
+ Timeout = time_ms(Timeout0),
+ cancel_default_timetrap(),
+ case get(test_server_multiply_timetraps) of
+ undefined -> timetrap1(Timeout);
+ infinity -> infinity;
+ Int -> timetrap1(Timeout*Int)
+ end.
+
+timetrap1(Timeout) ->
+ Ref = spawn_link(test_server_sup,timetrap,[Timeout,self()]),
+ case get(test_server_timetraps) of
+ undefined -> put(test_server_timetraps,[Ref]);
+ List -> put(test_server_timetraps,[Ref|List])
+ end,
+ Ref.
+
+ensure_timetrap(Config) ->
+ %format("ensure_timetrap:~p~n",[Config]),
+ case get(test_server_timetraps) of
+ [_|_] ->
+ ok;
+ _ ->
+ case get(test_server_default_timetrap) of
+ undefined -> ok;
+ Garbage ->
+ erase(test_server_default_timetrap),
+ format("=== WARNING: garbage in test_server_default_timetrap: ~p~n",
+ [Garbage])
+ end,
+ DTmo = case lists:keysearch(default_timeout,1,Config) of
+ {value,{default_timeout,Tmo}} -> Tmo;
+ _ -> ?DEFAULT_TIMETRAP_SECS
+ end,
+ format("=== test_server setting default timetrap of ~p seconds~n",
+ [DTmo]),
+ put(test_server_default_timetrap, timetrap(seconds(DTmo)))
+ end.
+
+cancel_default_timetrap() ->
+ case get(test_server_default_timetrap) of
+ undefined ->
+ ok;
+ TimeTrap when is_pid(TimeTrap) ->
+ timetrap_cancel(TimeTrap),
+ erase(test_server_default_timetrap),
+ format("=== test_server canceled default timetrap since another timetrap was set~n"),
+ ok;
+ Garbage ->
+ erase(test_server_default_timetrap),
+ format("=== WARNING: garbage in test_server_default_timetrap: ~p~n",
+ [Garbage]),
+ error
+ end.
+
+
+time_ms({hours,N}) -> hours(N);
+time_ms({minutes,N}) -> minutes(N);
+time_ms({seconds,N}) -> seconds(N);
+time_ms({Other,_N}) ->
+ format("=== ERROR: Invalid time specification: ~p. "
+ "Should be seconds, minutes, or hours.~n", [Other]),
+ exit({invalid_time_spec,Other});
+time_ms(Ms) when is_integer(Ms) -> Ms;
+time_ms(Other) -> exit({invalid_time_spec,Other}).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timetrap_cancel(Handle) -> ok
+%% Handle = term()
+%%
+%% Cancels a time trap.
+timetrap_cancel(infinity) ->
+ ok;
+timetrap_cancel(Handle) ->
+ case get(test_server_timetraps) of
+ undefined -> ok;
+ [Handle] -> erase(test_server_timetraps);
+ List -> put(test_server_timetraps,lists:delete(Handle,List))
+ end,
+ test_server_sup:timetrap_cancel(Handle).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% hours(N) -> Milliseconds
+%% minutes(N) -> Milliseconds
+%% seconds(N) -> Milliseconds
+%% N = integer() | float()
+%% Milliseconds = integer()
+%%
+%% Transforms the named units to milliseconds. Fractions in the input
+%% are accepted. The output is an integer.
+hours(N) -> trunc(N * 1000 * 60 * 60).
+minutes(N) -> trunc(N * 1000 * 60).
+seconds(N) -> trunc(N * 1000).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timecall(M,F,A) -> {Time,Val}
+%% Time = float()
+%%
+%% Measures the time spent evaluating MFA. The measurement is done with
+%% erlang:now/0, and should have pretty good accuracy on most platforms.
+%% The function is not evaluated in a catch context.
+timecall(M, F, A) ->
+ test_server_sup:timecall(M,F,A).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% do_times(N,M,F,A) -> ok
+%% do_times(N,Fun) ->
+%% N = integer()
+%% Fun = fun() -> void()
+%%
+%% Evaluates MFA or Fun N times, and returns ok.
+do_times(N,M,F,A) when N>0 ->
+ apply(M,F,A),
+ do_times(N-1,M,F,A);
+do_times(0,_,_,_) ->
+ ok.
+
+do_times(N,Fun) when N>0 ->
+ Fun(),
+ do_times(N-1,Fun);
+do_times(0,_) ->
+ ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% m_out_of_n(M,N,Fun) -> ok | exit({m_out_of_n_failed,{R,left_to_do}})
+%% M = integer()
+%% N = integer()
+%% Fun = fun() -> void()
+%% R = integer()
+%%
+%% Repeats evaluating the given function until it succeeded (didn't crash)
+%% M times. If, after N times, M successful attempts have not been
+%% accomplished, the process crashes with reason {m_out_of_n_failed
+%% {R,left_to_do}}, where R indicates how many cases that remained to be
+%% successfully completed.
+%%
+%% For example:
+%% m_out_of_n(1,4,fun() -> tricky_test_case() end)
+%% Tries to run tricky_test_case() up to 4 times,
+%% and is happy if it succeeds once.
+%%
+%% m_out_of_n(7,8,fun() -> clock_sanity_check() end)
+%% Tries running clock_sanity_check() up to 8
+%% times and allows the function to fail once.
+%% This might be useful if clock_sanity_check/0
+%% is known to fail if the clock crosses an hour
+%% boundary during the test (and the up to 8
+%% test runs could never cross 2 boundaries)
+m_out_of_n(0,_,_) ->
+ ok;
+m_out_of_n(M,0,_) ->
+ exit({m_out_of_n_failed,{M,left_to_do}});
+m_out_of_n(M,N,Fun) ->
+ case catch Fun() of
+ {'EXIT',_} ->
+ m_out_of_n(M,N-1,Fun);
+ _Other ->
+ m_out_of_n(M-1,N-1,Fun)
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%call_crash(M,F,A)
+%%call_crash(Time,M,F,A)
+%%call_crash(Time,Crash,M,F,A)
+%% M - atom()
+%% F - atom()
+%% A - [term()]
+%% Time - integer() in milliseconds.
+%% Crash - term()
+%%
+%% Spaws a new process that calls MFA. The call is considered
+%% successful if the call crashes with the given reason (Crash),
+%% or any other reason if Crash is not specified.
+%% ** The call must terminate withing the given Time (defaults
+%% to infinity), or it is considered a failure (exit with reason
+%% 'call_crash_timeout' is generated).
+
+call_crash(M,F,A) ->
+ call_crash(infinity,M,F,A).
+call_crash(Time,M,F,A) ->
+ call_crash(Time,any,M,F,A).
+call_crash(Time,Crash,M,F,A) ->
+ test_server_sup:call_crash(Time,Crash,M,F,A).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% start_node(SlaveName, Type, Options) ->
+%% {ok, Slave} | {error, Reason}
+%%
+%% SlaveName = string(), atom().
+%% Type = slave | peer
+%% Options = [{tuple(), term()}]
+%%
+%% OptionList is a tuplelist wich may contain one
+%% or more of these members:
+%%
+%% Slave and Peer:
+%% {remote, true} - Start the node on a remote host. If not specified,
+%% the node will be started on the local host (with
+%% some exceptions, as for the case of VxWorks and OSE,
+%% where all nodes are started on a remote host).
+%% {args, Arguments} - Arguments passed directly to the node.
+%% {cleanup, false} - Nodes started with this option will not be killed
+%% by the test server after completion of the test case
+%% Therefore it is IMPORTANT that the USER terminates
+%% the node!!
+%% {erl, ReleaseList} - Use an Erlang emulator determined by ReleaseList
+%% when starting nodes, instead of the same emulator
+%% as the test server is running. ReleaseList is a list
+%% of specifiers, where a specifier is either
+%% {release, Rel}, {prog, Prog}, or 'this'. Rel is
+%% either the name of a release, e.g., "r7a" or
+%% 'latest'. 'this' means using the same emulator as
+%% the test server. Prog is the name of an emulator
+%% executable. If the list has more than one element,
+%% one of them is picked randomly. (Only
+%% works on Solaris and Linux, and the test
+%% server gives warnings when it notices that
+%% nodes are not of the same version as
+%% itself.)
+%%
+%% Peer only:
+%% {wait, false} - Don't wait for the node to be started.
+%% {fail_on_error, false} - Returns {error, Reason} rather than failing
+%% the test case. This option can only be used with
+%% peer nodes.
+%% Note that slave nodes always act as if they had
+%% fail_on_error==false.
+%%
+
+start_node(Name, Type, Options) ->
+ lists:foreach(
+ fun(N) ->
+ case firstname(N) of
+ Name ->
+ format("=== WARNING: Trying to start node \'~w\' when node"
+ " with same first name exists: ~w", [Name, N]);
+ _other -> ok
+ end
+ end,
+ nodes()),
+
+ group_leader() ! {sync_apply,
+ self(),
+ {test_server_ctrl,start_node,[Name,Type,Options]}},
+ Result = receive {sync_result,R} -> R end,
+
+ case Result of
+ {ok,Node} ->
+
+ %% Cannot run cover on shielded node or on a node started
+ %% by a shielded node.
+ Cover = case is_cover() of
+ true ->
+ not is_shielded(Name) andalso same_version(Node);
+ false ->
+ false
+ end,
+
+ net_adm:ping(Node),
+ case Cover of
+ true ->
+ Sticky = unstick_all_sticky(Node),
+ cover:start(Node),
+ stick_all_sticky(Node,Sticky);
+ _ ->
+ ok
+ end,
+ {ok,Node};
+ {fail,Reason} -> fail(Reason);
+ Error -> Error
+ end.
+
+firstname(N) ->
+ list_to_atom(upto($@,atom_to_list(N))).
+
+%% This should!!! crash if H is not member in list.
+upto(H, [H | _T]) -> [];
+upto(H, [X | T]) -> [X | upto(H,T)].
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% wait_for_node(Name) -> ok | {error,timeout}
+%%
+%% If a node is started with the options {wait,false}, this function
+%% can be used to wait for the node to come up from the
+%% test server point of view (i.e. wait until it has contacted
+%% the test server controller after startup)
+wait_for_node(Slave) ->
+ group_leader() ! {sync_apply,
+ self(),
+ {test_server_ctrl,wait_for_node,[Slave]}},
+ receive {sync_result,R} -> R end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% stop_node(Name) -> true|false
+%%
+%% Kills a (remote) node.
+%% Also inform test_server_ctrl so it can clean up!
+stop_node(Slave) ->
+ Nocover = is_shielded(Slave) orelse not same_version(Slave),
+ case is_cover() of
+ true when not Nocover ->
+ Sticky = unstick_all_sticky(Slave),
+ cover:stop(Slave),
+ stick_all_sticky(Slave,Sticky);
+ _ ->
+ ok
+ end,
+ group_leader() ! {sync_apply,self(),{test_server_ctrl,stop_node,[Slave]}},
+ Result = receive {sync_result,R} -> R end,
+ case Result of
+ ok ->
+ erlang:monitor_node(Slave, true),
+ slave:stop(Slave),
+ receive
+ {nodedown, Slave} ->
+ format(minor, "Stopped slave node: ~p", [Slave]),
+ format(major, "=node_stop ~p", [Slave]),
+ true
+ after 30000 ->
+ format("=== WARNING: Node ~p does not seem to terminate.",
+ [Slave]),
+ false
+ end;
+ {error, _Reason} ->
+ %% Either, the node is already dead or it was started
+ %% with the {cleanup,false} option, or it was started
+ %% in some other way than test_server:start_node/3
+ format("=== WARNING: Attempt to stop a nonexisting slavenode (~p)~n"
+ "=== Trying to kill it anyway!!!",
+ [Slave]),
+ case net_adm:ping(Slave)of
+ pong ->
+ slave:stop(Slave),
+ true;
+ pang ->
+ false
+ end
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% is_release_available(Release) -> true | false
+%% Release -> string()
+%%
+%% Test if a release (such as "r10b") is available to be
+%% started using start_node/3.
+
+is_release_available(Release) ->
+ group_leader() ! {sync_apply,
+ self(),
+ {test_server_ctrl,is_release_available,[Release]}},
+ receive {sync_result,R} -> R end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% run_on_shielded_node(Fun, CArgs) -> term()
+%% Fun -> function()
+%% CArg -> list()
+%%
+%%
+%% Fun is executed in a process on a temporarily created
+%% hidden node. Communication with the job process goes
+%% via a job proxy process on the hidden node, i.e. the
+%% group leader of the test case process is the job proxy
+%% process. This makes it possible to start nodes from the
+%% hidden node that are unaware of the test server node.
+%% Without the job proxy process all processes would have
+%% a process residing on the test_server node as group_leader.
+%%
+%% Fun - Function to execute
+%% CArg - Extra command line arguments to use when starting
+%% the shielded node.
+%%
+%% If Fun is successfully executed, the result is returned.
+%%
+
+run_on_shielded_node(Fun, CArgs) when is_function(Fun), is_list(CArgs) ->
+ {A,B,C} = now(),
+ Name = "shielded_node-" ++ integer_to_list(A) ++ "-" ++ integer_to_list(B)
+ ++ "-" ++ integer_to_list(C),
+ Node = case start_node(Name, slave, [{args, "-hidden " ++ CArgs}]) of
+ {ok, N} -> N;
+ Err -> fail({failed_to_start_shielded_node, Err})
+ end,
+ Master = self(),
+ Ref = make_ref(),
+ Slave = spawn(Node,
+ fun () ->
+ start_job_proxy(),
+ receive
+ Ref ->
+ Master ! {Ref, Fun()}
+ end,
+ receive after infinity -> infinity end
+ end),
+ MRef = erlang:monitor(process, Slave),
+ Slave ! Ref,
+ receive
+ {'DOWN', MRef, _, _, Info} ->
+ stop_node(Node),
+ fail(Info);
+ {Ref, Res} ->
+ stop_node(Node),
+ receive
+ {'DOWN', MRef, _, _, _} ->
+ Res
+ end
+ end.
+
+%% Return true if Name or node() is a shielded node
+is_shielded(Name) ->
+ case {cast_to_list(Name),atom_to_list(node())} of
+ {"shielded_node"++_,_} -> true;
+ {_,"shielded_node"++_} -> true;
+ _ -> false
+ end.
+
+same_version(Name) ->
+ ThisVersion = erlang:system_info(version),
+ OtherVersion = rpc:call(Name, erlang, system_info, [version]),
+ ThisVersion =:= OtherVersion.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% temp_name(Stem) -> string()
+%% Stem = string()
+%%
+%% Create a unique file name, based on (starting with) Stem.
+%% A filename of the form <Stem><Number> is generated, and the
+%% function checks that that file doesn't already exist.
+temp_name(Stem) ->
+ {A,B,C} = erlang:now(),
+ RandomNum = A bxor B bxor C,
+ RandomName = Stem ++ integer_to_list(RandomNum),
+ {ok,Files} = file:list_dir(filename:dirname(Stem)),
+ case lists:member(RandomName,Files) of
+ true ->
+ %% oh, already exists - bad luck. Try again.
+ temp_name(Stem); %% recursively try again
+ false ->
+ RandomName
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% app_test/1
+%%
+app_test(App) ->
+ app_test(App, pedantic).
+app_test(App, Mode) ->
+ case os:type() of
+ {ose,_} ->
+ Comment = "Skipping app_test on OSE",
+ comment(Comment), % in case user ignores the return value
+ {skip,Comment};
+ _other ->
+ test_server_sup:app_test(App, Mode)
+ end.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% is_native(Mod) -> true | false
+%%
+%% Checks wether the module is natively compiled or not.
+
+is_native(Mod) ->
+ case catch Mod:module_info(native_addresses) of
+ [_|_] -> true;
+ _Other -> false
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% comment(String) -> ok
+%%
+%% The given String will occur in the comment field
+%% of the table on the test suite result page. If
+%% called several times, only the last comment is
+%% printed.
+%% comment/1 is also overwritten by the return value
+%% {comment,Comment} or fail/1 (which prints Reason
+%% as a comment).
+comment(String) ->
+ group_leader() ! {comment,String},
+ ok.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% os_type() -> OsType
+%%
+%% Returns the OsType of the target node. OsType is
+%% the same as returned from os:type()
+os_type() ->
+ test_server_ctrl:get_target_os_type().
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% is_cover() -> boolean()
+%%
+%% Returns true if cover is running, else false
+is_cover() ->
+ case whereis(cover_server) of
+ undefined -> false;
+ _ -> true
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% is_debug() -> boolean()
+%%
+%% Returns true if the emulator is debug-compiled, false otherwise.
+is_debug() ->
+ case catch erlang:system_info(debug_compiled) of
+ {'EXIT', _} ->
+ case string:str(erlang:system_info(system_version), "debug") of
+ Int when is_integer(Int), Int > 0 -> true;
+ _ -> false
+ end;
+ Res ->
+ Res
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% has_lock_checking() -> boolean()
+%%
+%% Returns true if the emulator has lock checking enabled, false otherwise.
+has_lock_checking() ->
+ case catch erlang:system_info(lock_checking) of
+ {'EXIT', _} -> false;
+ Res -> Res
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% has_superfluous_schedulers() -> boolean()
+%%
+%% Returns true if the emulator has more scheduler threads than logical
+%% processors, false otherwise.
+has_superfluous_schedulers() ->
+ case catch {erlang:system_info(schedulers),
+ erlang:system_info(logical_processors)} of
+ {S, P} when is_integer(S), is_integer(P), S > P -> true;
+ _ -> false
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% is_commercial_build() -> boolean()
+%%
+%% Returns true if the current emulator is commercially supported.
+%% (The emulator will not have "[source]" in its start-up message.)
+%% We might want to do more tests on a commercial platform, for instance
+%% ensuring that all applications have documentation).
+is_commercial() ->
+ case string:str(erlang:system_info(system_version), "source") of
+ Int when is_integer(Int), Int > 0 -> false;
+ _ -> true
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% DEBUGGER INTERFACE %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% purify_is_running() -> false|true
+%%
+%% Tests if Purify is currently running.
+
+purify_is_running() ->
+ case catch erlang:system_info({error_checker, running}) of
+ {'EXIT', _} -> false;
+ Res -> Res
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% purify_new_leaks() -> false|BytesLeaked
+%% BytesLeaked = integer()
+%%
+%% Checks for new memory leaks if Purify is active.
+%% Returns the number of bytes leaked, or false if Purify
+%% is not running.
+purify_new_leaks() ->
+ case catch erlang:system_info({error_checker, memory}) of
+ {'EXIT', _} -> false;
+ Leaked when is_integer(Leaked) -> Leaked
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% purify_new_fds_inuse() -> false|FdsInuse
+%% FdsInuse = integer()
+%%
+%% Checks for new file descriptors in use.
+%% Returns the number of new file descriptors in use, or false
+%% if Purify is not running.
+purify_new_fds_inuse() ->
+ case catch erlang:system_info({error_checker, fd}) of
+ {'EXIT', _} -> false;
+ Inuse when is_integer(Inuse) -> Inuse
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% purify_format(Format, Args) -> ok
+%% Format = string()
+%% Args = lists()
+%%
+%% Outputs the formatted string to Purify's logfile,if Purify is active.
+purify_format(Format, Args) ->
+ (catch erlang:system_info({error_checker, io_lib:format(Format, Args)})),
+ ok.
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% Generic send functions for communication with host
+%%
+sync_local_or_remote_apply(Proxy,From,{M,F,A} = MFA) ->
+ case get(test_server_job_sock) of
+ undefined ->
+ %% i'm a local target
+ Result = apply(M,F,A),
+ if is_pid(Proxy) -> Proxy ! {sync_result_proxy,From,Result};
+ true -> From ! {sync_result,Result}
+ end;
+ JobSock ->
+ %% i'm a remote target
+ request(JobSock,{sync_apply,MFA}),
+ {sync_result,Result} = recv(JobSock),
+ if is_pid(Proxy) -> Proxy ! {sync_result_proxy,From,Result};
+ true -> From ! {sync_result,Result}
+ end
+ end.
+local_or_remote_apply({M,F,A} = MFA) ->
+ case get(test_server_job_sock) of
+ undefined ->
+ %% i'm a local target
+ apply(M,F,A),
+ ok;
+ JobSock ->
+ %% i'm a remote target
+ request(JobSock,{apply,MFA}),
+ ok
+ end.
+
+request(Sock,Request) ->
+ gen_tcp:send(Sock,<<1,(term_to_binary(Request))/binary>>).
+
+%%
+%% Generic receive function for communication with host
+%%
+recv(Sock) ->
+ case gen_tcp:recv(Sock,0) of
+ {error,closed} ->
+ gen_tcp:close(Sock),
+ exit(connection_lost);
+ {ok,<<1,Request/binary>>} ->
+ binary_to_term(Request);
+ {ok,<<0,B/binary>>} ->
+ B
+ end.
diff --git a/lib/test_server/src/test_server_ctrl.erl b/lib/test_server/src/test_server_ctrl.erl
new file mode 100644
index 0000000000..667d0cc051
--- /dev/null
+++ b/lib/test_server/src/test_server_ctrl.erl
@@ -0,0 +1,5253 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2002-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(test_server_ctrl).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% %%
+%% The Erlang Test Server %%
+%% %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% MODULE DEPENDENCIES:
+%% HARD TO REMOVE: erlang, lists, io_lib, gen_server, file, io, string,
+%% code, ets, rpc, gen_tcp, inet, erl_tar, sets,
+%% test_server, test_server_sup, test_server_node
+%% EASIER TO REMOVE: filename, filelib, lib, re
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% ARCHITECTURE
+%%
+%% The Erlang Test Server can be run on the target machine (local target)
+%% or towards a remote target. The execution flow is mainly the same in
+%% both cases, but with a remote target the test cases are (obviously)
+%% executed on the target machine. Host and target communicates over
+%% socket connections because the host should not be introduced as an
+%% additional node in the distributed erlang system in which the test
+%% cases are run.
+%%
+%%
+%% Local Target:
+%% =============
+%%
+%% -----
+%% | | test_server_ctrl ({global,test_server})
+%% ----- (test_server_ctrl.erl)
+%% |
+%% |
+%% -----
+%% | | JobProc
+%% ----- (test_server_ctrl.erl and test_server.erl)
+%% |
+%% |
+%% -----
+%% | | CaseProc
+%% ----- (test_server.erl)
+%%
+%%
+%%
+%% test_server_ctrl is the main process in the system. It is a registered
+%% process, and it will always be alive when testing is ongoing.
+%% test_server_ctrl initiates testing and monitors JobProc(s).
+%%
+%% When target is local, and Test Server is *not* being used by a framework
+%% application (where it might cause duplicate name problems in a distributed
+%% test environment), the process is globally registered as 'test_server'
+%% to be able to simulate the {global,test_server} process on a remote target.
+%%
+%% JobProc is spawned for each 'job' added to the test_server_ctrl.
+%% A job can mean one test case, one test suite or one spec.
+%% JobProc creates and writes logs and presents results from testing.
+%% JobProc is the group leader for CaseProc.
+%%
+%% CaseProc is spawned for each test case. It runs the test case and
+%% sends results and any other information to its group leader - JobProc.
+%%
+%%
+%%
+%% Remote Target:
+%% ==============
+%%
+%% HOST TARGET
+%%
+%% ----- MainSock -----
+%% test_server_ctrl | |- - - - - - -| | {global,test_server}
+%% (test_server_ctrl.erl) ----- ----- (test_server.erl)
+%% | |
+%% | |
+%% ----- JobSock -----
+%% JobProcH | |- - - - - - -| | JobProcT
+%% (test_server_ctrl.erl) ----- ----- (test_server.erl)
+%% |
+%% |
+%% -----
+%% | | CaseProc
+%% ----- (test_server.erl)
+%%
+%%
+%%
+%%
+%% A separate test_server process only exists when target is remote. It
+%% is then the main process on target. It is started when test_server_ctrl
+%% is started, and a socket connection is established between
+%% test_server_ctrl and test_server. The following information can be sent
+%% over MainSock:
+%%
+%% HOST TARGET
+%% -> {target_info, TargetInfo} (during initiation)
+%% <- {job_proc_killed,Name,Reason} (if a JobProcT dies unexpectedly)
+%% -> {job,Port,Name} (to start a new JobProcT)
+%%
+%%
+%% When target is remote, JobProc is split into to processes: JobProcH
+%% executing on Host and JobProcT executing on Target. (The two processes
+%% execute the same code as JobProc does when target is local.) JobProcH
+%% and JobProcT communicates over a socket connection. The following
+%% information can be sent over JobSock:
+%%
+%% HOST TARGET
+%% -> {test_case, Case} To start a new test case
+%% -> {beam,Mod} .beam file as binary to be loaded
+%% on target, e.g. a test suite
+%% -> {datadir,Tarfile} Content of the datadir for a test suite
+%% <- {apply,MFA} MFA to be applied on host, ignore return;
+%% (apply is used for printing information in
+%% log or console)
+%% <- {sync_apply,MFA} MFA to be applied on host, wait for return
+%% (used for starting and stopping slave nodes)
+%% -> {sync_apply,MFA} MFA to be applied on target, wait for return
+%% (used for cover compiling and analysing)
+%% <-> {sync_result,Result} Return value from sync_apply
+%% <- {test_case_result,Result} When a test case is finished
+%% <- {crash_dumps,Tarfile} When a test case is finished
+%% -> job_done When a job is finished
+%% <- {privdir,Privdir} When a job is finished
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+
+%%% SUPERVISOR INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([start/0, start/1, start_link/1, stop/0]).
+
+%%% OPERATOR INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([add_spec/1, add_dir/2, add_dir/3]).
+-export([add_module/1, add_module/2, add_case/2, add_case/3, add_cases/2,
+ add_cases/3]).
+-export([add_dir_with_skip/3, add_dir_with_skip/4, add_tests_with_skip/3]).
+-export([add_module_with_skip/2, add_module_with_skip/3,
+ add_case_with_skip/3, add_case_with_skip/4,
+ add_cases_with_skip/3, add_cases_with_skip/4]).
+-export([jobs/0, run_test/1, wait_finish/0, idle_notify/1,
+ abort_current_testcase/1, abort/0]).
+-export([start_get_totals/1, stop_get_totals/0]).
+-export([get_levels/0, set_levels/3]).
+-export([multiply_timetraps/1]).
+-export([cover/2, cover/3, cover/7,
+ cross_cover_analyse/1, cross_cover_analyse/2, trc/1, stop_trace/0]).
+-export([testcase_callback/1]).
+-export([set_random_seed/1]).
+
+%%% TEST_SERVER INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([output/2, print/2, print/3, print_timestamp/2]).
+-export([start_node/3, stop_node/1, wait_for_node/1, is_release_available/1]).
+-export([format/1, format/2, format/3]).
+-export([get_target_info/0]).
+-export([get_hosts/0]).
+-export([get_target_os_type/0]).
+-export([node_started/1]).
+
+%%% DEBUGGER INTERFACE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([i/0, p/1, p/3, pi/2, pi/4, t/0, t/1]).
+
+%%% PRIVATE EXPORTED %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+-export([init/1, terminate/2]).
+-export([handle_call/3, handle_cast/2, handle_info/2]).
+-export([do_test_cases/4]).
+-export([do_spec/2, do_spec_list/2]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-include("test_server_internal.hrl").
+-include_lib("kernel/include/file.hrl").
+-define(suite_ext, "_SUITE").
+-define(log_ext, ".log.html").
+-define(src_listing_ext, ".src.html").
+-define(logdir_ext, ".logs").
+-define(data_dir_suffix, "_data/").
+-define(suitelog_name, "suite.log").
+-define(coverlog_name, "cover.html").
+-define(cross_coverlog_name, "cross_cover.html").
+-define(cover_total, "total_cover.log").
+-define(last_file, "last_name").
+-define(last_link, "last_link").
+-define(last_test, "last_test").
+-define(html_ext, ".html").
+-define(cross_cover_file, "cross.cover").
+-define(now, erlang:now()).
+
+-define(pl2a(M), test_server_sup:package_atom(M)).
+-define(void_fun, fun() -> ok end).
+-define(mod_result(X), if X == skip -> skipped;
+ X == auto_skip -> skipped;
+ true -> X end).
+
+-record(state,{jobs=[],levels={1,19,10},multiply_timetraps=1,finish=false,
+ target_info, trc=false, cover=false, wait_for_node=[],
+ testcase_callback=undefined, idle_notify=[],
+ get_totals=false, random_seed=undefined}).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% OPERATOR INTERFACE
+
+add_dir(Name, Job=[Dir|_Dirs]) when is_list(Dir) ->
+ add_job(cast_to_list(Name),
+ lists:map(fun(D)-> {dir,cast_to_list(D)} end, Job));
+add_dir(Name, Dir) ->
+ add_job(cast_to_list(Name), {dir,cast_to_list(Dir)}).
+
+add_dir(Name, Job=[Dir|_Dirs], Pattern) when is_list(Dir) ->
+ add_job(cast_to_list(Name),
+ lists:map(fun(D)-> {dir,cast_to_list(D),
+ cast_to_list(Pattern)} end, Job));
+add_dir(Name, Dir, Pattern) ->
+ add_job(cast_to_list(Name), {dir,cast_to_list(Dir),cast_to_list(Pattern)}).
+
+add_module(Mod) when is_atom(Mod) ->
+ add_job(atom_to_list(Mod), {Mod,all}).
+add_module(Name, Mods) when is_list(Mods) ->
+ add_job(cast_to_list(Name), lists:map(fun(Mod) -> {Mod,all} end, Mods)).
+
+add_case(Mod, Case) when is_atom(Mod), is_atom(Case) ->
+ add_job(atom_to_list(Mod), {Mod,Case}).
+
+add_case(Name, Mod, Case) when is_atom(Mod), is_atom(Case) ->
+ add_job(Name, {Mod,Case}).
+
+add_cases(Mod, Cases) when is_atom(Mod), is_list(Cases) ->
+ add_job(atom_to_list(Mod), {Mod,Cases}).
+
+add_cases(Name, Mod, Cases) when is_atom(Mod), is_list(Cases) ->
+ add_job(Name, {Mod,Cases}).
+
+add_spec(Spec) ->
+ Name = filename:rootname(Spec, ".spec"),
+ case filelib:is_file(Spec) of
+ true -> add_job(Name, {spec,Spec});
+ false -> {error,nofile}
+ end.
+
+%% This version of the interface is to be used if there are
+%% suites or cases that should be skipped.
+
+add_dir_with_skip(Name, Job=[Dir|_Dirs], Skip) when is_list(Dir) ->
+ add_job(cast_to_list(Name),
+ lists:map(fun(D)-> {dir,cast_to_list(D)} end, Job),
+ Skip);
+add_dir_with_skip(Name, Dir, Skip) ->
+ add_job(cast_to_list(Name), {dir,cast_to_list(Dir)}, Skip).
+
+add_dir_with_skip(Name, Job=[Dir|_Dirs], Pattern, Skip) when is_list(Dir) ->
+ add_job(cast_to_list(Name),
+ lists:map(fun(D)-> {dir,cast_to_list(D),
+ cast_to_list(Pattern)} end, Job),
+ Skip);
+add_dir_with_skip(Name, Dir, Pattern, Skip) ->
+ add_job(cast_to_list(Name),
+ {dir,cast_to_list(Dir),cast_to_list(Pattern)}, Skip).
+
+add_module_with_skip(Mod, Skip) when is_atom(Mod) ->
+ add_job(atom_to_list(Mod), {Mod,all}, Skip).
+
+add_module_with_skip(Name, Mods, Skip) when is_list(Mods) ->
+ add_job(cast_to_list(Name), lists:map(fun(Mod) -> {Mod,all} end, Mods), Skip).
+
+add_case_with_skip(Mod, Case, Skip) when is_atom(Mod), is_atom(Case) ->
+ add_job(atom_to_list(Mod), {Mod,Case}, Skip).
+
+add_case_with_skip(Name, Mod, Case, Skip) when is_atom(Mod), is_atom(Case) ->
+ add_job(Name, {Mod,Case}, Skip).
+
+add_cases_with_skip(Mod, Cases, Skip) when is_atom(Mod), is_list(Cases) ->
+ add_job(atom_to_list(Mod), {Mod,Cases}, Skip).
+
+add_cases_with_skip(Name, Mod, Cases, Skip) when is_atom(Mod), is_list(Cases) ->
+ add_job(Name, {Mod,Cases}, Skip).
+
+add_tests_with_skip(LogDir, Tests, Skip) ->
+ add_job(LogDir,
+ lists:map(fun({Dir,all,all}) ->
+ {Dir,{dir,Dir}};
+ ({Dir,Mods,all}) ->
+ {Dir,lists:map(fun(M) -> {M,all} end, Mods)};
+ ({Dir,Mod,Cases}) ->
+ {Dir,{Mod,Cases}}
+ end, Tests),
+ Skip).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% COMMAND LINE INTERFACE
+
+parse_cmd_line(Cmds) ->
+ parse_cmd_line(Cmds, [], [], local, false, false, undefined).
+
+parse_cmd_line(['SPEC',Spec|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ case file:consult(Spec) of
+ {ok, TermList} ->
+ Name = filename:rootname(Spec),
+ parse_cmd_line(Cmds, TermList++SpecList, [Name|Names], Param,
+ Trc, Cov, TCCB);
+ {error,Reason} ->
+ io:format("Can't open ~s: ~p\n",
+ [cast_to_list(Spec), file:format_error(Reason)]),
+ parse_cmd_line(Cmds, SpecList, Names, Param, Trc, Cov, TCCB)
+ end;
+parse_cmd_line(['NAME',Name|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, SpecList, [{name,Name}|Names], Param, Trc, Cov, TCCB);
+parse_cmd_line(['SKIPMOD',Mod|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, [{skip,{Mod,"by command line"}}|SpecList], Names,
+ Param, Trc, Cov, TCCB);
+parse_cmd_line(['SKIPCASE',Mod,Case|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, [{skip,{Mod,Case,"by command line"}}|SpecList], Names,
+ Param, Trc, Cov, TCCB);
+parse_cmd_line(['DIR',Dir|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ Name = cast_to_list(filename:basename(Dir)),
+ parse_cmd_line(Cmds, [{topcase,{dir,Name}}|SpecList], [Name|Names],
+ Param, Trc, Cov, TCCB);
+parse_cmd_line(['MODULE',Mod|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, [{topcase,{Mod,all}}|SpecList], [Mod|Names],
+ Param, Trc, Cov, TCCB);
+parse_cmd_line(['CASE',Mod,Case|Cmds], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, [{topcase,{Mod,Case}}|SpecList], [Mod|Names],
+ Param, Trc, Cov, TCCB);
+parse_cmd_line(['PARAMETERS',Param|Cmds], SpecList, Names, _Param, Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, SpecList, Names, Param, Trc, Cov, TCCB);
+parse_cmd_line(['TRACE',Trc|Cmds], SpecList, Names, Param, _Trc, Cov, TCCB) ->
+ parse_cmd_line(Cmds, SpecList, Names, Param, Trc, Cov, TCCB);
+parse_cmd_line(['COVER',App,CF,Analyse|Cmds], SpecList, Names, Param, Trc, _Cov, TCCB) ->
+ parse_cmd_line(Cmds, SpecList, Names, Param, Trc, {{App,CF}, Analyse}, TCCB);
+parse_cmd_line(['TESTCASE_CALLBACK',Mod,Func|Cmds], SpecList, Names, Param, Trc, Cov, _) ->
+ parse_cmd_line(Cmds, SpecList, Names, Param, Trc, Cov, {Mod,Func});
+parse_cmd_line([Obj|_Cmds], _SpecList, _Names, _Param, _Trc, _Cov, _TCCB) ->
+ io:format("~p: Bad argument: ~p\n", [?MODULE,Obj]),
+ io:format(" Use the `ts' module to start tests.\n", []),
+ io:format(" (If you ARE using `ts', there is a bug in `ts'.)\n", []),
+ halt(1);
+parse_cmd_line([], SpecList, Names, Param, Trc, Cov, TCCB) ->
+ NameList = lists:reverse(Names, [suite]),
+ Name = case lists:keysearch(name, 1, NameList) of
+ {value,{name,N}} -> N;
+ false -> hd(NameList)
+ end,
+ {lists:reverse(SpecList), cast_to_list(Name), Param, Trc, Cov, TCCB}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% cast_to_list(X) -> string()
+%% X = list() | atom() | void()
+%% Returns a string representation of whatever was input
+
+cast_to_list(X) when is_list(X) -> X;
+cast_to_list(X) when is_atom(X) -> atom_to_list(X);
+cast_to_list(X) -> lists:flatten(io_lib:format("~w", [X])).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% START INTERFACE
+
+start() ->
+ start(local).
+
+start(Param) ->
+ case gen_server:start({local,?MODULE}, ?MODULE, [Param], []) of
+ {ok, Pid} ->
+ {ok, Pid};
+ Other ->
+ Other
+ end.
+
+start_link(Param) ->
+ case gen_server:start_link({local,?MODULE}, ?MODULE, [Param], []) of
+ {ok, Pid} ->
+ {ok, Pid};
+ Other ->
+ Other
+ end.
+
+run_test(CommandLine) ->
+ process_flag(trap_exit,true),
+ {SpecList,Name,Param,Trc,Cov,TCCB} = parse_cmd_line(CommandLine),
+ {ok,_TSPid} = start_link(Param),
+ case Trc of
+ false -> ok;
+ File -> trc(File)
+ end,
+ case Cov of
+ false -> ok;
+ {{App,CoverFile},Analyse} -> cover(App, maybe_file(CoverFile), Analyse)
+ end,
+ testcase_callback(TCCB),
+ add_job(Name, {command_line,SpecList}),
+
+ %% adding of jobs involves file i/o which may take long time
+ %% when running a nfs mounted file system (VxWorks).
+ case controller_call(get_target_info) of
+ #target_info{os_family=vxworks} ->
+ receive after 30000 -> ready_to_wait end;
+ _ ->
+ wait_now
+ end,
+ wait_finish().
+
+%% Converted CoverFile to a string unless it is 'none'
+maybe_file(none) ->
+ none;
+maybe_file(CoverFile) ->
+ atom_to_list(CoverFile).
+
+idle_notify(Fun) ->
+ {ok, Pid} = controller_call({idle_notify,Fun}),
+ Pid.
+
+start_get_totals(Fun) ->
+ {ok, Pid} = controller_call({start_get_totals,Fun}),
+ Pid.
+
+stop_get_totals() ->
+ ok = controller_call(stop_get_totals),
+ ok.
+
+wait_finish() ->
+ OldTrap = process_flag(trap_exit, true),
+ {ok, Pid} = finish(true),
+ link(Pid),
+ receive
+ {'EXIT',Pid,_} ->
+ ok
+ end,
+ process_flag(trap_exit, OldTrap),
+ ok.
+
+abort_current_testcase(Reason) ->
+ controller_call({abort_current_testcase,Reason}),
+ ok.
+
+abort() ->
+ OldTrap = process_flag(trap_exit, true),
+ {ok, Pid} = finish(abort),
+ link(Pid),
+ receive
+ {'EXIT',Pid,_} ->
+ ok
+ end,
+ process_flag(trap_exit, OldTrap),
+ ok.
+
+finish(Abort) ->
+ controller_call({finish,Abort}).
+
+stop() ->
+ controller_call(stop).
+
+jobs() ->
+ controller_call(jobs).
+
+get_levels() ->
+ controller_call(get_levels).
+
+set_levels(Show, Major, Minor) ->
+ controller_call({set_levels,Show,Major,Minor}).
+
+multiply_timetraps(N) ->
+ controller_call({multiply_timetraps,N}).
+
+trc(TraceFile) ->
+ controller_call({trace,TraceFile}, 2*?ACCEPT_TIMEOUT).
+
+stop_trace() ->
+ controller_call(stop_trace).
+
+node_started(Node) ->
+ gen_server:cast(?MODULE, {node_started,Node}).
+
+cover(App, Analyse) when is_atom(App) ->
+ cover(App, none, Analyse);
+cover(CoverFile, Analyse) ->
+ cover(none, CoverFile, Analyse).
+cover(App, CoverFile, Analyse) ->
+ controller_call({cover,{App,CoverFile},Analyse}).
+cover(App, CoverFile, Exclude, Include, Cross, Export, Analyse) ->
+ controller_call({cover,{App,{CoverFile,Exclude,Include,Cross,Export}},Analyse}).
+
+testcase_callback(ModFunc) ->
+ controller_call({testcase_callback,ModFunc}).
+
+set_random_seed(Seed) ->
+ controller_call({set_random_seed,Seed}).
+
+get_hosts() ->
+ get(test_server_hosts).
+
+get_target_os_type() ->
+ case whereis(?MODULE) of
+ undefined ->
+ %% This is probably called on the target node
+ os:type();
+ _pid ->
+ %% This is called on the controller, e.g. from a
+ %% specification clause of a test case
+ #target_info{os_type=OsType} = controller_call(get_target_info),
+ OsType
+ end.
+
+%%--------------------------------------------------------------------
+
+add_job(Name, TopCase) ->
+ add_job(Name, TopCase, []).
+
+add_job(Name, TopCase, Skip) ->
+ SuiteName =
+ case Name of
+ "." -> "current_dir";
+ ".." -> "parent_dir";
+ Other -> Other
+ end,
+ Dir = filename:absname(SuiteName),
+ controller_call({add_job,Dir,SuiteName,TopCase,Skip}).
+
+controller_call(Arg) ->
+ case catch gen_server:call(?MODULE, Arg, infinity) of
+ {'EXIT',{{badarg,_},{gen_server,call,_}}} ->
+ exit(test_server_ctrl_not_running);
+ {'EXIT',Reason} ->
+ exit(Reason);
+ Other ->
+ Other
+ end.
+controller_call(Arg, Timeout) ->
+ case catch gen_server:call(?MODULE, Arg, Timeout) of
+ {'EXIT',{{badarg,_},{gen_server,call,_}}} ->
+ exit(test_server_ctrl_not_running);
+ {'EXIT',Reason} ->
+ exit(Reason);
+ Other ->
+ Other
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% init([Mode])
+%% Mode = lazy | error_logger
+%% StateFile = string()
+%% ReadMode = ignore_errors | halt_on_errors
+%%
+%% init() is the init function of the test_server's gen_server.
+%% When Mode=error_logger: The init function of the test_server's gen_event
+%% event handler used as a replacement error_logger when running test_suites.
+%%
+%% The init function reads the test server state file, to see what test
+%% suites were running when the test server was last running, and which
+%% flags that were in effect. If no state file is found, or there are
+%% errors in it, defaults are used.
+%%
+%% Mode 'lazy' ignores (and resets to []) any jobs in the state file
+%%
+
+init([Param]) ->
+ case os:getenv("TEST_SERVER_CALL_TRACE") of
+ false ->
+ ok;
+ "" ->
+ ok;
+ TraceSpec ->
+ test_server_sup:call_trace(TraceSpec)
+ end,
+ process_flag(trap_exit, true),
+ case lists:keysearch(sasl, 1, application:which_applications()) of
+ {value,_} ->
+ test_server_h:install();
+ false ->
+ ok
+ end,
+ %% copy format_exception setting from init arg to application environment
+ case init:get_argument(test_server_format_exception) of
+ {ok,[[TSFE]]} ->
+ application:set_env(test_server, format_exception, list_to_atom(TSFE));
+ _ ->
+ ok
+ end,
+ test_server_sup:cleanup_crash_dumps(),
+ State = #state{jobs=[],finish=false},
+ put(test_server_free_targets,[]),
+ case contact_main_target(Param) of
+ {ok,TI} ->
+ ets:new(slave_tab, [named_table,set,public,{keypos,2}]),
+ set_hosts([TI#target_info.host]),
+ {ok,State#state{target_info=TI}};
+ {error,Reason} ->
+ {stop,Reason}
+ end.
+
+
+%% If the test is to be run at a remote target, this function sets up
+%% a socket communication with the target.
+contact_main_target(local) ->
+ %% When used by a general framework, global registration of
+ %% test_server should not be required.
+ case os:getenv("TEST_SERVER_FRAMEWORK") of
+ false ->
+ %% Local target! The global test_server process implemented by
+ %% test_server.erl will not be started, so we simulate it by
+ %% globally registering this process instead.
+ global:sync(),
+ case global:whereis_name(test_server) of
+ undefined ->
+ global:register_name(test_server, self());
+ Pid ->
+ case node() of
+ N when N == node(Pid) ->
+ io:format(user, "Warning: test_server already running!\n", []),
+ global:re_register_name(test_server,self());
+ _ ->
+ ok
+ end
+ end;
+ _ ->
+ ok
+ end,
+ TI = test_server:init_target_info(),
+ TargetHost = test_server_sup:hoststr(),
+ {ok,TI#target_info{where=local,
+ host=TargetHost,
+ naming=naming(),
+ master=TargetHost}};
+
+contact_main_target(ParameterFile) ->
+ case read_parameters(ParameterFile) of
+ {ok,Par} ->
+ case test_server_node:start_remote_main_target(Par) of
+ {ok,TI} ->
+ {ok,TI};
+ {error,Error} ->
+ {error,{could_not_start_main_target,Error}}
+ end;
+ {error,Error} ->
+ {error,{could_not_read_parameterfile,Error}}
+ end.
+
+read_parameters(File) ->
+ case file:consult(File) of
+ {ok,Data} ->
+ read_parameters(lists:flatten(Data), #par{naming=naming()});
+ Error ->
+ Error
+ end.
+read_parameters([{type,Type}|Data], Par) -> % mandatory
+ read_parameters(Data, Par#par{type=Type});
+read_parameters([{target,Target}|Data], Par) -> % mandatory
+ read_parameters(Data, Par#par{target=cast_to_list(Target)});
+read_parameters([{slavetargets,SlaveTargets}|Data], Par) ->
+ read_parameters(Data, Par#par{slave_targets=SlaveTargets});
+read_parameters([{longnames,Bool}|Data], Par) ->
+ Naming = if Bool->"-name"; true->"-sname" end,
+ read_parameters(Data, Par#par{naming=Naming});
+read_parameters([{master,{Node,Cookie}}|Data], Par) ->
+ read_parameters(Data, Par#par{master=cast_to_list(Node),
+ cookie=cast_to_list(Cookie)});
+read_parameters([Other|_Data], _Par) ->
+ {error,{illegal_parameter,Other}};
+read_parameters([], Par) when Par#par.type==undefined ->
+ {error, {missing_mandatory_parameter,type}};
+read_parameters([], Par) when Par#par.target==undefined ->
+ {error, {missing_mandatory_parameter,target}};
+read_parameters([], Par0) ->
+ Par =
+ case {Par0#par.type, Par0#par.master} of
+ {ose, undefined} ->
+ %% Use this node as master and bootserver for target
+ %% and slave nodes
+ Par0#par{master = atom_to_list(node()),
+ cookie = atom_to_list(erlang:get_cookie())};
+ {ose, _Master} ->
+ %% Master for target and slave nodes was defined in parameterfile
+ Par0;
+ _ ->
+ %% Use target as master for slave nodes,
+ %% (No master is used for target)
+ Par0#par{master="test_server@" ++ Par0#par.target}
+ end,
+ {ok,Par}.
+
+naming() ->
+ case lists:member($., test_server_sup:hoststr()) of
+ true -> "-name";
+ false -> "-sname"
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(kill_slavenodes, From, State) -> ok
+%%
+%% Kill all slave nodes that remain after a test case
+%% is completed.
+%%
+handle_call(kill_slavenodes, _From, State) ->
+ Nodes = test_server_node:kill_nodes(State#state.target_info),
+ {reply, Nodes, State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({set_hosts, HostList}, From, State) -> ok
+%%
+%% Set the global hostlist.
+%%
+handle_call({set_hosts, Hosts}, _From, State) ->
+ set_hosts(Hosts),
+ {reply, ok, State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(get_hosts, From, State) -> [Hosts]
+%%
+%% Returns the lists of hosts that the test server
+%% can use for slave nodes. This is primarily used
+%% for nodename generation.
+%%
+handle_call(get_hosts, _From, State) ->
+ Hosts = get_hosts(),
+ {reply, Hosts, State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({add_job,Dir,Name,TopCase,Skip}, _, State) ->
+%% ok | {error,Reason}
+%%
+%% Dir = string()
+%% Name = string()
+%% TopCase = term()
+%% Skip = [SkipItem]
+%% SkipItem = {Mod,Comment} | {Mod,Case,Comment} | {Mod,Cases,Comment}
+%% Mod = Case = atom()
+%% Comment = string()
+%% Cases = [Case]
+%%
+%% Adds a job to the job queue. The name of the job is Name. A log directory
+%% will be created in Dir/Name.logs. TopCase may be anything that
+%% collect_cases/3 accepts, plus the following:
+%%
+%% {spec,SpecName} executes the named test suite specification file. Commands
+%% in the file should be in the format accepted by do_spec_list/1.
+%%
+%% {command_line,SpecList} executes the list of specification instructions
+%% supplied, which should be in the format accepted by do_spec_list/1.
+
+handle_call({add_job,Dir,Name,TopCase,Skip}, _From, State) ->
+ LogDir = Dir ++ ?logdir_ext,
+ ExtraTools =
+ case State#state.cover of
+ false -> [];
+ {App,Analyse} -> [{cover,App,Analyse}]
+ end,
+ ExtraTools1 =
+ case State#state.random_seed of
+ undefined -> ExtraTools;
+ Seed -> [{random_seed,Seed}|ExtraTools]
+ end,
+ case lists:keysearch(Name, 1, State#state.jobs) of
+ false ->
+ case TopCase of
+ {spec,SpecName} ->
+ Pid = spawn_tester(
+ ?MODULE, do_spec,
+ [SpecName,State#state.multiply_timetraps],
+ LogDir, Name, State#state.levels,
+ State#state.testcase_callback, ExtraTools1),
+ NewJobs = [{Name,Pid}|State#state.jobs],
+ {reply, ok, State#state{jobs=NewJobs}};
+ {command_line,SpecList} ->
+ Pid = spawn_tester(
+ ?MODULE, do_spec_list,
+ [SpecList,State#state.multiply_timetraps],
+ LogDir, Name, State#state.levels,
+ State#state.testcase_callback, ExtraTools1),
+ NewJobs = [{Name,Pid}|State#state.jobs],
+ {reply, ok, State#state{jobs=NewJobs}};
+ TopCase ->
+ case State#state.get_totals of
+ {CliPid,Fun} ->
+ Result = count_test_cases(TopCase, Skip),
+ Fun(CliPid, Result),
+ {reply, ok, State};
+ _ ->
+ Cfg = make_config([]),
+ Pid = spawn_tester(
+ ?MODULE, do_test_cases,
+ [TopCase,Skip,Cfg,
+ State#state.multiply_timetraps],
+ LogDir, Name, State#state.levels,
+ State#state.testcase_callback, ExtraTools1),
+ NewJobs = [{Name,Pid}|State#state.jobs],
+ {reply, ok, State#state{jobs=NewJobs}}
+ end
+ end;
+ _ ->
+ {reply,{error,name_already_in_use},State}
+ end;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(jobs, _, State) -> JobList
+%% JobList = [{Name,Pid}, ...]
+%% Name = string()
+%% Pid = pid()
+%%
+%% Return the list of current jobs.
+
+handle_call(jobs, _From, State) ->
+ {reply,State#state.jobs,State};
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({abort_current_testcase,Reason}, _, State) -> Result
+%% Reason = term()
+%% Result = ok | {error,no_testcase_running}
+%%
+%% Attempts to abort the test case that's currently running.
+
+handle_call({abort_current_testcase,Reason}, _From, State) ->
+ case State#state.jobs of
+ [{_,Pid}|_] ->
+ Pid ! {abort_current_testcase,Reason,self()},
+ receive
+ {Pid,abort_current_testcase,Result} ->
+ {reply, Result, State}
+ after 10000 ->
+ {reply, {error,no_testcase_running}, State}
+ end;
+ _ ->
+ {reply, {error,no_testcase_running}, State}
+ end;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({finish,Fini}, _, State) -> {ok,Pid}
+%% Fini = true | abort
+%%
+%% Tells the test_server to stop as soon as there are no test suites
+%% running. Immediately if none are running. Abort is handled as soon
+%% as current test finishes.
+
+handle_call({finish,Fini}, _From, State) ->
+ case State#state.jobs of
+ [] ->
+ lists:foreach(fun({Cli,Fun}) -> Fun(Cli) end,
+ State#state.idle_notify),
+ State2 = State#state{finish=false},
+ {stop,shutdown,{ok,self()}, State2};
+ _SomeJobs ->
+ State2 = State#state{finish=Fini},
+ {reply, {ok,self()}, State2}
+ end;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({idle_notify,Fun}, From, State) -> {ok,Pid}
+%%
+%% Lets a test client subscribe to receive a notification when the
+%% test server becomes idle (can be used to syncronize jobs).
+%% test_server calls Fun(From) when idle.
+
+handle_call({idle_notify,Fun}, {Cli,_Ref}, State) ->
+ case State#state.jobs of
+ [] ->
+ Fun(Cli),
+ {reply, {ok,self()}, State};
+ _ ->
+ Subscribed = State#state.idle_notify,
+ {reply, {ok,self()},
+ State#state{idle_notify=[{Cli,Fun}|Subscribed]}}
+ end;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(start_get_totals, From, State) -> {ok,Pid}
+%%
+%% Switch on the mode where the test server will only
+%% report back the number of tests it would execute
+%% given some subsequent jobs.
+
+handle_call({start_get_totals,Fun}, {Cli,_Ref}, State) ->
+ {reply, {ok,self()}, State#state{get_totals={Cli,Fun}}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(stop_get_totals, From, State) -> ok
+%%
+%% Lets a test client subscribe to receive a notification when the
+%% test server becomes idle (can be used to syncronize jobs).
+%% test_server calls Fun(From) when idle.
+
+handle_call(stop_get_totals, {_Cli,_Ref}, State) ->
+ {reply, ok, State#state{get_totals=false}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(get_levels, _, State) -> {Show,Major,Minor}
+%% Show = integer()
+%% Major = integer()
+%% Minor = integer()
+%%
+%% Returns a 3-tuple with the logging thresholds.
+%% All output and information from a test suite is tagged with a detail
+%% level. Lower values are more "important". Text that is output using
+%% io:format or similar is automatically tagged with detail level 50.
+%%
+%% All output with detail level:
+%% less or equal to Show is displayed on the screen (default 1)
+%% less or equal to Major is logged in the major log file (default 19)
+%% greater or equal to Minor is logged in the minor log files (default 10)
+
+handle_call(get_levels, _From, State) ->
+ {reply,State#state.levels,State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({set_levels,Show,Major,Minor}, _, State) -> ok
+%% Show = integer()
+%% Major = integer()
+%% Minor = integer()
+%%
+%% Sets the logging thresholds, see handle_call(get_levels,...) above.
+
+handle_call({set_levels,Show,Major,Minor}, _From, State) ->
+ {reply,ok,State#state{levels={Show,Major,Minor}}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({multiply_timetraps,N}, _, State) -> ok
+%% N = integer() | infinity
+%%
+%% Multiplies all timetraps set by test cases with N
+
+handle_call({multiply_timetraps,N}, _From, State) ->
+ {reply,ok,State#state{multiply_timetraps=N}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({trace,TraceFile}, _, State) -> ok | {error,Reason}
+%%
+%% Starts a separate node (trace control node) which
+%% starts tracing on target and all slave nodes
+%%
+%% TraceFile is a text file with elements of type
+%% {Trace,Mod,TracePattern}.
+%% {Trace,Mod,Func,TracePattern}.
+%% {Trace,Mod,Func,Arity,TracePattern}.
+%%
+%% Trace = tp | tpl; local or global call trace
+%% Mod,Func = atom(), Arity=integer(); defines what to trace
+%% TracePattern = [] | match_spec()
+%%
+%% The 'call' trace flag is set on all processes, and then
+%% the given trace patterns are set.
+
+handle_call({trace,TraceFile}, _From, State=#state{trc=false}) ->
+ TI = State#state.target_info,
+ case test_server_node:start_tracer_node(TraceFile, TI) of
+ {ok,Tracer} -> {reply,ok,State#state{trc=Tracer}};
+ Error -> {reply,Error,State}
+ end;
+handle_call({trace,_TraceFile}, _From, State) ->
+ {reply,{error,already_tracing},State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(stop_trace, _, State) -> ok | {error,Reason}
+%%
+%% Stops tracing on target and all slave nodes and
+%% terminates trace control node
+
+handle_call(stop_trace, _From, State=#state{trc=false}) ->
+ {reply,{error,not_tracing},State};
+handle_call(stop_trace, _From, State) ->
+ R = test_server_node:stop_tracer_node(State#state.trc),
+ {reply,R,State#state{trc=false}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({cover,App,Analyse}, _, State) -> ok | {error,Reason}
+%%
+%% All modules inn application App are cover compiled
+%% Analyse indicates on which level the coverage should be analysed
+
+handle_call({cover,App,Analyse}, _From, State) ->
+ {reply,ok,State#state{cover={App,Analyse}}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({testcase_callback,{Mod,Func}}, _, State) -> ok | {error,Reason}
+%%
+%% Add a callback function that will be called before and after every
+%% test case (on the test case process):
+%%
+%% Mod:Func(Suite,TestCase,InitOrEnd,Config)
+%%
+%% InitOrEnd = init | 'end'.
+
+handle_call({testcase_callback,ModFunc}, _From, State) ->
+ case ModFunc of
+ {Mod,Func} ->
+ case code:is_loaded(Mod) of
+ {file,_} ->
+ ok;
+ false ->
+ code:load_file(Mod)
+ end,
+ case erlang:function_exported(Mod,Func,4) of
+ true ->
+ ok;
+ false ->
+ io:format(user,
+ "WARNING! Callback function ~w:~w/4 undefined.~n~n",
+ [Mod,Func])
+ end;
+ _ ->
+ ok
+ end,
+ {reply,ok,State#state{testcase_callback=ModFunc}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({set_random_seed,Seed}, _, State) -> ok | {error,Reason}
+%%
+%% Let operator set a random seed value to be used e.g. for shuffling
+%% test cases.
+
+handle_call({set_random_seed,Seed}, _From, State) ->
+ {reply,ok,State#state{random_seed=Seed}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(stop, _, State) -> ok
+%%
+%% Stops the test server immediately.
+%% Some cleanup is done by terminate/2
+
+handle_call(stop, _From, State) ->
+ {stop, shutdown, ok, State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call(get_target_info, _, State) -> TI
+%%
+%% TI = #target_info{}
+%%
+%% Returns information about target
+
+handle_call(get_target_info, _From, State) ->
+ {reply, State#state.target_info, State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({start_node,Name,Type,Options}, _, State) ->
+%% ok | {error,Reason}
+%%
+%% Starts a new node (slave or peer)
+
+handle_call({start_node, Name, Type, Options}, From, State) ->
+ %% test_server_ctrl does gen_server:reply/2 explicitly
+ test_server_node:start_node(Name, Type, Options, From,
+ State#state.target_info),
+ {noreply,State};
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({wait_for_node,Node}, _, State) -> ok
+%%
+%% Waits for a new node to take contact. Used if
+%% node is started with option {wait,false}
+
+handle_call({wait_for_node, Node}, From, State) ->
+ NewWaitList =
+ case ets:lookup(slave_tab,Node) of
+ [] ->
+ [{Node,From}|State#state.wait_for_node];
+ _ ->
+ gen_server:reply(From,ok),
+ State#state.wait_for_node
+ end,
+ {noreply,State#state{wait_for_node=NewWaitList}};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({stop_node,Name}, _, State) -> ok | {error,Reason}
+%%
+%% Stops a slave or peer node. This is actually only some cleanup
+%% - the node is really stopped by test_server when this returns.
+
+handle_call({stop_node, Name}, _From, State) ->
+ R = test_server_node:stop_node(Name, State#state.target_info),
+ {reply, R, State};
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_call({stop_node,Name}, _, State) -> ok | {error,Reason}
+%%
+%% Tests if the release is available.
+
+handle_call({is_release_available, Release}, _From, State) ->
+ R = test_server_node:is_release_available(Release),
+ {reply, R, State}.
+
+%%--------------------------------------------------------------------
+set_hosts(Hosts) ->
+ put(test_server_hosts, Hosts).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_cast({node_started,Name}, _, State)
+%%
+%% Called by test_server_node when a slave/peer node is fully started.
+
+handle_cast({node_started,Node}, State) ->
+ case State#state.trc of
+ false -> ok;
+ Trc -> test_server_node:trace_nodes(Trc, [Node])
+ end,
+ NewWaitList =
+ case lists:keysearch(Node,1,State#state.wait_for_node) of
+ {value,{Node,From}} ->
+ gen_server:reply(From, ok),
+ lists:keydelete(Node, 1, State#state.wait_for_node);
+ false ->
+ State#state.wait_for_node
+ end,
+ {noreply, State#state{wait_for_node=NewWaitList}}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_info({'EXIT',Pid,Reason}, State)
+%% Pid = pid()
+%% Reason = term()
+%%
+%% Handles exit messages from linked processes. Only test suites and
+%% possibly a target client are expected to be linked.
+%% When a test suite terminates, it is removed from the job queue.
+%% If a target client terminates it means that we lost contact with
+%% target. The test_server_ctrl process is terminated, and teminate/2
+%% will do the cleanup
+
+handle_info({'EXIT',Pid,Reason}, State) ->
+ case lists:keysearch(Pid,2,State#state.jobs) of
+ false ->
+ TI = State#state.target_info,
+ case TI#target_info.target_client of
+ Pid ->
+ %% The target client died - lost contact with target
+ {stop,{lost_contact_with_target,Reason},State};
+ _other ->
+ %% not our problem
+ {noreply,State}
+ end;
+ {value,{Name,_}} ->
+ NewJobs = lists:keydelete(Pid, 2, State#state.jobs),
+ case Reason of
+ normal ->
+ fine;
+ killed ->
+ io:format("Suite ~s was killed\n", [Name]);
+ _Other ->
+ io:format("Suite ~s was killed with reason ~p\n",
+ [Name,Reason])
+ end,
+ State2 = State#state{jobs=NewJobs},
+ case NewJobs of
+ [] ->
+ lists:foreach(fun({Cli,Fun}) -> Fun(Cli) end,
+ State2#state.idle_notify),
+ case State2#state.finish of
+ false ->
+ {noreply,State2#state{idle_notify=[]}};
+ _ -> % true | abort
+ %% test_server:finish() has been called and
+ %% there are no jobs in the job queue =>
+ %% stop the test_server_ctrl
+ {stop,shutdown,State2#state{finish=false}}
+ end;
+ _ -> % pending jobs
+ case State2#state.finish of
+ abort -> % abort test now!
+ lists:foreach(fun({Cli,Fun}) -> Fun(Cli) end,
+ State2#state.idle_notify),
+ {stop,shutdown,State2#state{finish=false}};
+ _ -> % true | false
+ {noreply, State2}
+ end
+ end
+ end;
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_info({tcp,Sock,Bin}, State)
+%%
+%% Message from remote main target process
+%% Only valid message is 'job_proc_killed', which indicates
+%% that a process running a test suite was killed
+
+handle_info({tcp,_MainSock,<<1,Request/binary>>}, State) ->
+ case binary_to_term(Request) of
+ {job_proc_killed,Name,Reason} ->
+ %% The only purpose of this is to inform the user about what
+ %% happened on target.
+ %% The local job proc will soon be killed by the closed socket or
+ %% because the job is finished. Then the above clause ('EXIT') will
+ %% handle the problem.
+ io:format("Suite ~s was killed on remote target with reason"
+ " ~p\n", [Name,Reason]);
+ _ ->
+ ignore
+ end,
+ {noreply,State};
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_info({tcp_closed,Sock}, State)
+%%
+%% A Socket was closed. This indicates that a node died.
+%% This can be
+%% *Target node (if remote)
+%% *Slave or peer node started by a test suite
+%% *Trace controll node
+
+handle_info({tcp_closed,Sock}, State=#state{trc=Sock}) ->
+ %% Tracer node died - can't really do anything
+ %%! Maybe print something???
+ {noreply,State#state{trc=false}};
+handle_info({tcp_closed,Sock}, State) ->
+ case test_server_node:nodedown(Sock,State#state.target_info) of
+ target_died ->
+ %% terminate/2 will do the cleanup
+ {stop,target_died,State};
+ _ ->
+ {noreply,State}
+ end;
+
+handle_info(_, State) ->
+ %% dummy; accept all, do nothing.
+ {noreply, State}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% terminate(Reason, State) -> ok
+%% Reason = term()
+%%
+%% Cleans up when the test_server is terminating. Kills the running
+%% test suites (if any) and terminates the remote target (if is exists)
+
+terminate(_Reason, State) ->
+ case State#state.trc of
+ false -> ok;
+ Sock -> test_server_node:stop_tracer_node(Sock)
+ end,
+ kill_all_jobs(State#state.jobs),
+ test_server_node:stop(State#state.target_info),
+ ok.
+
+kill_all_jobs([{_Name,JobPid}|Jobs]) ->
+ exit(JobPid, kill),
+ kill_all_jobs(Jobs);
+kill_all_jobs([]) ->
+ ok.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%----------------------- INTERNAL FUNCTIONS -----------------------%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% spawn_tester(Mod, Func, Args, Dir, Name, Levels,
+%% TestCaseCallback, ExtraTools) -> Pid
+%% Mod = atom()
+%% Func = atom()
+%% Args = [term(),...]
+%% Dir = string()
+%% Name = string()
+%% Levels = {integer(),integer(),integer()}
+%% TestCaseCallback = {CBMod,CBFunc} | undefined
+%% ExtraTools = [ExtraTool,...]
+%% ExtraTool = CoverInfo | TraceInfo | RandomSeed
+%%
+%% Spawns a test suite execute-process, just an ordinary spawn, except
+%% that it will set a lot of dictionary information before starting the
+%% named function. Also, the execution is timed and protected by a catch.
+%% When the named function is done executing, a summary of the results
+%% is printed to the log files.
+
+spawn_tester(Mod, Func, Args, Dir, Name, Levels, TCCallback, ExtraTools) ->
+ spawn_link(
+ fun() -> init_tester(Mod, Func, Args, Dir, Name, Levels,
+ TCCallback, ExtraTools)
+ end).
+
+init_tester(Mod, Func, Args, Dir, Name, {SumLev,MajLev,MinLev},
+ TCCallback, ExtraTools) ->
+ process_flag(trap_exit, true),
+ put(test_server_name, Name),
+ put(test_server_dir, Dir),
+ put(test_server_total_time, 0),
+ put(test_server_ok, 0),
+ put(test_server_failed, 0),
+ put(test_server_skipped, {0,0}),
+ put(test_server_summary_level, SumLev),
+ put(test_server_major_level, MajLev),
+ put(test_server_minor_level, MinLev),
+ put(test_server_random_seed, proplists:get_value(random_seed, ExtraTools)),
+ put(test_server_testcase_callback, TCCallback),
+ StartedExtraTools = start_extra_tools(ExtraTools),
+ {TimeMy,Result} = ts_tc(Mod, Func, Args),
+ put(test_server_common_io_handler, undefined),
+ stop_extra_tools(StartedExtraTools),
+ case Result of
+ {'EXIT',test_suites_done} ->
+ print(25, "DONE, normal exit", []);
+ {'EXIT',_Pid,Reason} ->
+ print(1, "EXIT, reason ~p", [Reason]);
+ {'EXIT',Reason} ->
+ print(1, "EXIT, reason ~p", [Reason]);
+ _Other ->
+ print(25, "DONE", [])
+ end,
+ Time = TimeMy/1000000,
+ SuccessStr =
+ case get(test_server_failed) of
+ 0 -> "Ok";
+ _ -> "FAILED"
+ end,
+ {SkippedN,SkipStr} =
+ case get(test_server_skipped) of
+ {0,_} -> {0,""};
+ {Skipped,_} -> {Skipped,io_lib:format(", ~p Skipped", [Skipped])}
+ end,
+ OkN = get(test_server_ok),
+ FailedN = get(test_server_failed),
+ print(html,"<tr><td></td><td><b>TOTAL</b></td><td></td><td></td>"
+ "<td>~.3fs</td><td><b>~s</b></td><td>~p Ok, ~p Failed~s of ~p</td></tr>\n",
+ [Time,SuccessStr,OkN,FailedN,SkipStr,OkN+FailedN+SkippedN]).
+
+%% timer:tc/3
+ts_tc(M, F, A) ->
+ Before = ?now,
+ Val = (catch apply(M, F, A)),
+ After = ?now,
+ Elapsed = elapsed_time(Before, After),
+ {Elapsed,Val}.
+
+elapsed_time(Before, After) ->
+ (element(1,After)*1000000000000 +
+ element(2,After)*1000000 + element(3,After)) -
+ (element(1,Before)*1000000000000 +
+ element(2,Before)*1000000 + element(3,Before)).
+
+start_extra_tools(ExtraTools) ->
+ start_extra_tools(ExtraTools, []).
+start_extra_tools([{cover,App,Analyse} | ExtraTools], Started) ->
+ case cover_compile(App) of
+ {ok,AnalyseMods} ->
+ start_extra_tools(ExtraTools,
+ [{cover,App,Analyse,AnalyseMods}|Started]);
+ {error,_} ->
+ start_extra_tools(ExtraTools, Started)
+ end;
+start_extra_tools([_ | ExtraTools], Started) ->
+ start_extra_tools(ExtraTools, Started);
+start_extra_tools([], Started) ->
+ Started.
+
+stop_extra_tools(ExtraTools) ->
+ TestDir = get(test_server_log_dir_base),
+ case lists:keymember(cover, 1, ExtraTools) of
+ false ->
+ write_default_coverlog(TestDir);
+ true ->
+ ok
+ end,
+ stop_extra_tools(ExtraTools, TestDir).
+
+stop_extra_tools([{cover,App,Analyse,AnalyseMods}|ExtraTools], TestDir) ->
+ cover_analyse(App, Analyse, AnalyseMods, TestDir),
+ stop_extra_tools(ExtraTools, TestDir);
+%%stop_extra_tools([_ | ExtraTools], TestDir) ->
+%% stop_extra_tools(ExtraTools, TestDir);
+stop_extra_tools([], _) ->
+ ok.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% do_spec(SpecName, MultiplyTimetrap) -> {error,Reason} | exit(Result)
+%% SpecName = string()
+%% MultiplyTimetrap = integer() | infinity
+%%
+%% Reads the named test suite specification file, and executes it.
+%%
+%% This function is meant to be called by a process created by
+%% spawn_tester/7, which sets up some necessary dictionary values.
+
+do_spec(SpecName, MultiplyTimetrap) when is_list(SpecName) ->
+ case file:consult(SpecName) of
+ {ok,TermList} ->
+ do_spec_list(TermList,MultiplyTimetrap);
+ {error,Reason} ->
+ io:format("Can't open ~s: ~p\n", [SpecName,Reason]),
+ {error,{cant_open_spec,Reason}}
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% do_spec_list(TermList) -> exit(Result)
+%% TermList = [term()|...]
+%% MultiplyTimetrap = integer() | infinity
+%%
+%% Executes a list of test suite specification commands. The following
+%% commands are available, and may occur zero or more times (if several,
+%% the contents is appended):
+%%
+%% {topcase,TopCase} Specifies top level test goals. TopCase has the syntax
+%% specified by collect_cases/3.
+%%
+%% {skip,Skip} Specifies test cases to skip, and lists requirements that
+%% cannot be granted during the test run. Skip has the syntax specified
+%% by collect_cases/3.
+%%
+%% {nodes,Nodes} Lists node names avaliable to the test suites. Nodes have
+%% the syntax specified by collect_cases/3.
+%%
+%% {require_nodenames, Num} Specifies how many nodenames the test suite will
+%% need. Theese are automaticly generated and inserted into the Config by the
+%% test_server. The caller may specify other hosts to run theese nodes by
+%% using the {hosts, Hosts} option. If there are no hosts specified, all
+%% nodenames will be generated from the local host.
+%%
+%% {hosts, Hosts} Specifies a list of available hosts on which to start
+%% slave nodes. It is used when the {remote, true} option is given to the
+%% test_server:start_node/3 function. Also, if {require_nodenames, Num} is
+%% contained in the TermList, the generated nodenames will be spread over
+%% all hosts given in this Hosts list. The hostnames are given as atoms or
+%% strings.
+%%
+%% {diskless, true}</c></tag> is kept for backwards compatiblilty and
+%% should not be used. Use a configuration test case instead.
+%%
+%% This function is meant to be called by a process created by
+%% spawn_tester/7, which sets up some necessary dictionary values.
+
+do_spec_list(TermList0, MultiplyTimetrap) ->
+ Nodes = [],
+ TermList =
+ case lists:keysearch(hosts, 1, TermList0) of
+ {value, {hosts, Hosts0}} ->
+ Hosts = lists:map(fun(H) -> cast_to_list(H) end, Hosts0),
+ controller_call({set_hosts, Hosts}),
+ lists:keydelete(hosts, 1, TermList0);
+ _ ->
+ TermList0
+ end,
+ DefaultConfig = make_config([{nodes,Nodes}]),
+ {TopCases,SkipList,Config} = do_spec_terms(TermList, [], [], DefaultConfig),
+ do_test_cases(TopCases, SkipList, Config, MultiplyTimetrap).
+
+do_spec_terms([], TopCases, SkipList, Config) ->
+ {TopCases,SkipList,Config};
+do_spec_terms([{topcase,TopCase}|Terms], TopCases, SkipList, Config) ->
+ do_spec_terms(Terms,[TopCase|TopCases], SkipList, Config);
+do_spec_terms([{skip,Skip}|Terms], TopCases, SkipList, Config) ->
+ do_spec_terms(Terms, TopCases, [Skip|SkipList], Config);
+do_spec_terms([{nodes,Nodes}|Terms], TopCases, SkipList, Config) ->
+ do_spec_terms(Terms, TopCases, SkipList,
+ update_config(Config, {nodes,Nodes}));
+do_spec_terms([{diskless,How}|Terms], TopCases, SkipList, Config) ->
+ do_spec_terms(Terms, TopCases, SkipList,
+ update_config(Config, {diskless,How}));
+do_spec_terms([{config,MoreConfig}|Terms], TopCases, SkipList, Config) ->
+ do_spec_terms(Terms, TopCases, SkipList, Config++MoreConfig);
+do_spec_terms([{default_timeout,Tmo}|Terms], TopCases, SkipList, Config) ->
+ do_spec_terms(Terms, TopCases, SkipList,
+ update_config(Config, {default_timeout,Tmo}));
+
+do_spec_terms([{require_nodenames,NumNames}|Terms], TopCases, SkipList, Config) ->
+ NodeNames0=generate_nodenames(NumNames),
+ NodeNames=lists:delete([], NodeNames0),
+ do_spec_terms(Terms, TopCases, SkipList,
+ update_config(Config, {nodenames,NodeNames}));
+do_spec_terms([Other|Terms], TopCases, SkipList, Config) ->
+ io:format("** WARNING: Spec file contains unknown directive ~p\n",
+ [Other]),
+ do_spec_terms(Terms, TopCases, SkipList, Config).
+
+
+
+generate_nodenames(Num) ->
+ Hosts = case controller_call(get_hosts) of
+ [] ->
+ TI = controller_call(get_target_info),
+ [TI#target_info.host];
+ List ->
+ List
+ end,
+ generate_nodenames2(Num, Hosts, []).
+
+generate_nodenames2(0, _Hosts, Acc) ->
+ Acc;
+generate_nodenames2(N, Hosts, Acc) ->
+ Host=cast_to_list(lists:nth((N rem (length(Hosts)))+1, Hosts)),
+ Name=list_to_atom(temp_nodename("nod", []) ++ "@" ++ Host),
+ generate_nodenames2(N-1, Hosts, [Name|Acc]).
+
+temp_nodename([], Acc) ->
+ lists:flatten(Acc);
+temp_nodename([Chr|Base], Acc) ->
+ {A,B,C} = ?now,
+ New = [Chr | integer_to_list(Chr bxor A bxor B+A bxor C+B)],
+ temp_nodename(Base, [New|Acc]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% count_test_cases(TopCases, SkipCases) -> {Suites,NoOfCases} | error
+%% TopCases = term() (See collect_cases/3)
+%% SkipCases = term() (See collect_cases/3)
+%% Suites = list()
+%% NoOfCases = integer() | unknown
+%%
+%% Counts the test cases that are about to run and returns that number.
+%% If there's a conf group in TestSpec with a repeat property, the total number
+%% of cases can not be calculated and NoOfCases = unknown.
+count_test_cases(TopCases, SkipCases) when is_list(TopCases) ->
+ case collect_all_cases(TopCases, SkipCases) of
+ {error,_} ->
+ error;
+ TestSpec ->
+ {get_suites(TestSpec, []),
+ case remove_conf(TestSpec) of
+ {repeats,_} ->
+ unknown;
+ TestSpec1 ->
+ length(TestSpec1)
+ end}
+ end;
+
+count_test_cases(TopCase, SkipCases) ->
+ count_test_cases([TopCase], SkipCases).
+
+
+remove_conf(Cases) ->
+ remove_conf(Cases, [], false).
+
+remove_conf([{conf, _Ref, Props, _MF}|Cases], NoConf, Repeats) ->
+ case get_repeat(Props) of
+ undefined ->
+ remove_conf(Cases, NoConf, Repeats);
+ _ ->
+ remove_conf(Cases, NoConf, true)
+ end;
+remove_conf([{make,_Ref,_MF}|Cases], NoConf, Repeats) ->
+ remove_conf(Cases, NoConf, Repeats);
+remove_conf([{skip_case,{Type,_Ref,_MF,_Cmt}}|Cases],
+ NoConf, Repeats) when Type==conf;
+ Type==make ->
+ remove_conf(Cases, NoConf, Repeats);
+remove_conf([C|Cases], NoConf, Repeats) ->
+ remove_conf(Cases, [C|NoConf], Repeats);
+remove_conf([], NoConf, true) ->
+ {repeats,lists:reverse(NoConf)};
+remove_conf([], NoConf, false) ->
+ lists:reverse(NoConf).
+
+get_suites([{Mod,_Case}|Tests], Mods) when is_atom(Mod) ->
+ case add_mod(Mod, Mods) of
+ true -> get_suites(Tests, [Mod|Mods]);
+ false -> get_suites(Tests, Mods)
+ end;
+get_suites([{Mod,_Func,_Args}|Tests], Mods) when is_atom(Mod) ->
+ case add_mod(Mod, Mods) of
+ true -> get_suites(Tests, [Mod|Mods]);
+ false -> get_suites(Tests, Mods)
+ end;
+get_suites([_|Tests], Mods) ->
+ get_suites(Tests, Mods);
+
+get_suites([], Mods) ->
+ lists:reverse(Mods).
+
+add_mod(Mod, Mods) ->
+ case string:rstr(atom_to_list(Mod), "_SUITE") of
+ 0 -> false;
+ _ -> % test suite
+ case lists:member(Mod, Mods) of
+ true -> false;
+ false -> true
+ end
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% do_test_cases(TopCases, SkipCases, Config, MultiplyTimetrap) ->
+%% exit(Result)
+%%
+%% TopCases = term() (See collect_cases/3)
+%% SkipCases = term() (See collect_cases/3)
+%% Config = term() (See collect_cases/3)
+%% MultiplyTimetrap = integer() | infinity
+%%
+%% Initializes and starts the test run, for "ordinary" test suites.
+%% Creates log directories and log files, inserts initial timestamps and
+%% configuration information into the log files.
+%%
+%% This function is meant to be called by a process created by
+%% spawn_tester/7, which sets up some necessary dictionary values.
+
+do_test_cases(TopCases, SkipCases, Config, MultiplyTimetrap) when is_list(TopCases) ->
+ start_log_file(),
+ case collect_all_cases(TopCases, SkipCases) of
+ {error,Why} ->
+ print(1, "Error starting: ~p", [Why]),
+ exit(test_suites_done);
+ TestSpec0 ->
+ N = case remove_conf(TestSpec0) of
+ {repeats,_} -> unknown;
+ TS -> length(TS)
+ end,
+ put(test_server_cases, N),
+ put(test_server_case_num, 0),
+ TestSpec =
+ add_init_and_end_per_suite(TestSpec0, undefined, undefined),
+ TI = get_target_info(),
+ print(1, "Starting test~s", [print_if_known(N, {", ~w test cases",[N]},
+ {" (with repeated test cases)",[]})]),
+ test_server_sup:framework_call(report, [tests_start,
+ {get(test_server_name),N}]),
+ print(html,
+ "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<html>\n"
+ "<head><title>Test ~p results</title>\n"
+ "<meta http-equiv=\"cache-control\" content=\"no-cache\">\n"
+ "</head>\n"
+ "<body bgcolor=\"white\" text=\"black\" "
+ "link=\"blue\" vlink=\"purple\" alink=\"red\">"
+ "<h2>Results from test ~p</h2>\n",
+ [get(test_server_name),get(test_server_name)]),
+ print_timestamp(html, "Test started at "),
+
+ print(html, "<p>Host:<br>\n"),
+ print_who(test_server_sup:hoststr(), test_server_sup:get_username()),
+ print(html, "<br>Used Erlang ~s in <tt>~s</tt>.\n",
+ [erlang:system_info(version), code:root_dir()]),
+
+ case os:getenv("TEST_SERVER_FRAMEWORK") of
+ false ->
+ print(html, "<p>Target:<br>\n"),
+ print_who(TI#target_info.host, TI#target_info.username),
+ print(html, "<br>Used Erlang ~s in <tt>~s</tt>.\n",
+ [TI#target_info.version, TI#target_info.root_dir]);
+ _ ->
+ case test_server_sup:framework_call(target_info, []) of
+ TargetInfo when is_list(TargetInfo),
+ length(TargetInfo) > 0 ->
+ print(html, "<p>Target:<br>\n"),
+ print(html, "~s\n", [TargetInfo]);
+ _ ->
+ ok
+ end
+ end,
+
+ print(html,
+ "<p><a href=\"~s\">Full textual log</a>\n"
+ "<br><a href=\"~s\">Coverage log</a>\n",
+ [?suitelog_name,?coverlog_name]),
+ print(html,"<p>~s"
+ "<p>\n"
+ "<table border=3 cellpadding=5>"
+ "<tr><th>Num</th><th>Module</th><th>Case</th><th>Log</th>"
+ "<th>Time</th><th>Result</th><th>Comment</th></tr>\n",
+ [print_if_known(N, {"Suite contains ~p test cases.\n",[N]},
+ {"",[]})]),
+ print(major, "=cases ~p", [get(test_server_cases)]),
+ print(major, "=user ~s", [TI#target_info.username]),
+ print(major, "=host ~s", [TI#target_info.host]),
+
+ %% If there are no hosts specified,use only the local host
+ case controller_call(get_hosts) of
+ [] ->
+ print(major, "=hosts ~s", [TI#target_info.host]),
+ controller_call({set_hosts, [TI#target_info.host]});
+ Hosts ->
+ Str = lists:flatten(lists:map(fun(X) -> [X," "] end, Hosts)),
+ print(major, "=hosts ~s", [Str])
+ end,
+ print(major, "=emulator_vsn ~s", [TI#target_info.version]),
+ print(major, "=emulator ~s", [TI#target_info.emulator]),
+ print(major, "=otp_release ~s", [TI#target_info.otp_release]),
+ print(major, "=started ~s",
+ [lists:flatten(timestamp_get(""))]),
+ run_test_cases(TestSpec, Config, MultiplyTimetrap)
+ end;
+
+do_test_cases(TopCase, SkipCases, Config, MultiplyTimetrap) ->
+ %% when not list(TopCase)
+ do_test_cases([TopCase], SkipCases, Config, MultiplyTimetrap).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% start_log_file() -> ok | exit({Error,Reason})
+%% Stem = string()
+%%
+%% Creates the log directories, the major log file and the html log file.
+%% The log files are initialized with some header information.
+%%
+%% The name of the log directory will be <Name>.LOGS/run.<Date>/ where
+%% Name is the test suite name and Date is the current date and time.
+
+start_log_file() ->
+ Dir = get(test_server_dir),
+ case file:make_dir(Dir) of
+ ok ->
+ ok;
+ {error, eexist} ->
+ ok;
+ MkDirError ->
+ exit({cant_create_log_dir,{MkDirError,Dir}})
+ end,
+ TestDir = timestamp_filename_get(filename:join(Dir, "run.")),
+ case file:make_dir(TestDir) of
+ ok ->
+ ok;
+ MkDirError2 ->
+ exit({cant_create_log_dir,{MkDirError2,TestDir}})
+ end,
+
+ ok = file:write_file(filename:join(Dir, ?last_file), TestDir ++ "\n"),
+ ok = file:write_file(?last_file, TestDir ++ "\n"),
+
+ put(test_server_log_dir_base,TestDir),
+ MajorName = filename:join(TestDir, ?suitelog_name),
+ HtmlName = MajorName ++ ?html_ext,
+ {ok,Major} = file:open(MajorName, [write]),
+ {ok,Html} = file:open(HtmlName, [write]),
+ put(test_server_major_fd,Major),
+ put(test_server_html_fd,Html),
+
+ make_html_link(filename:absname(?last_test ++ ?html_ext),
+ HtmlName, filename:basename(Dir)),
+ LinkName = filename:join(Dir, ?last_link),
+ make_html_link(LinkName ++ ?html_ext, HtmlName,
+ filename:basename(Dir)),
+
+ PrivDir = filename:join(TestDir, ?priv_dir),
+ ok = file:make_dir(PrivDir),
+ put(test_server_priv_dir,PrivDir++"/"),
+ print_timestamp(13,"Suite started at "),
+ ok.
+
+make_html_link(LinkName, Target, Explanation) ->
+ %% if possible use a relative reference�to�Target.
+ TargetL = filename:split(Target),
+ PwdL = filename:split(filename:dirname(LinkName)),
+ Href = case lists:prefix(PwdL, TargetL) of
+ true ->
+ filename:join(lists:nthtail(length(PwdL), TargetL));
+ false ->
+ "file:" ++ Target
+ end,
+ H = io_lib:format("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<html>\n"
+ "<head><title>~s</title></head>\n"
+ "<body bgcolor=\"white\" text=\"black\""
+ " link=\"blue\" vlink=\"purple\" alink=\"red\">\n"
+ "<h1>Last test</h1>\n"
+ "<a href=\"~s\">~s</a>~n"
+ "</body>\n</html>\n",
+ [Explanation,Href,Explanation]),
+ ok = file:write_file(LinkName, H).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% start_minor_log_file(Mod, Func) -> AbsName
+%% Mod = atom()
+%% Func = atom()
+%% AbsName = string()
+%%
+%% Create a minor log file for the test case Mod,Func,Args. The log file
+%% will be stored in the log directory under the name <Mod>.<Func>.log.
+%% Some header info will also be inserted into the log file.
+
+start_minor_log_file(Mod, Func) ->
+ LogDir = get(test_server_log_dir_base),
+ Name0 = lists:flatten(io_lib:format("~s.~s~s", [Mod,Func,?html_ext])),
+ Name = downcase(Name0),
+ AbsName = filename:join(LogDir, Name),
+ case file:read_file_info(AbsName) of
+ {error,_} -> %% normal case, unique name
+ start_minor_log_file1(Mod, Func, LogDir, AbsName);
+ {ok,_} -> %% special case, duplicate names
+ {_,S,Us} = now(),
+ Name1_0 =
+ lists:flatten(io_lib:format("~s.~s.~w.~w~s", [Mod,Func,S,
+ trunc(Us/1000),
+ ?html_ext])),
+ Name1 = downcase(Name1_0),
+ AbsName1 = filename:join(LogDir, Name1),
+ start_minor_log_file1(Mod, Func, LogDir, AbsName1)
+ end.
+
+start_minor_log_file1(Mod, Func, LogDir, AbsName) ->
+ {ok,Fd} = file:open(AbsName, [write]),
+ Lev = get(test_server_minor_level)+1000, %% far down in the minor levels
+ put(test_server_minor_fd, Fd),
+ io:fwrite(Fd,
+ "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<html>\n"
+ "<head><title>"++cast_to_list(Mod)++"</title>\n"
+ "<meta http-equiv=\"cache-control\" content=\"no-cache\">\n"
+ "</head>\n"
+ "<body bgcolor=\"white\" text=\"black\""
+ " link=\"blue\" vlink=\"purple\" alink=\"red\">\n",
+ []),
+
+ SrcListing = downcase(cast_to_list(Mod)) ++ ?src_listing_ext,
+ case filelib:is_file(filename:join(LogDir, SrcListing)) of
+ true ->
+ print(Lev, "<a href=\"~s#~s\">source code for ~p:~p/1</a>\n",
+ [SrcListing,Func,Mod,Func]);
+ false -> ok
+ end,
+
+ io:fwrite(Fd, "<pre>\n", []),
+
+% Stupid BUG!
+% case catch apply(Mod, Func, [doc]) of
+% {'EXIT', _Why} -> ok;
+% Comment -> print(Lev, "Comment: ~s~n<br>", [Comment])
+% end,
+
+ AbsName.
+
+stop_minor_log_file() ->
+ Fd = get(test_server_minor_fd),
+ io:fwrite(Fd, "</pre>\n</body>\n</html>\n", []),
+ file:close(Fd),
+ put(test_server_minor_fd, undefined).
+
+downcase(S) -> downcase(S, []).
+downcase([Uc|Rest], Result) when $A =< Uc, Uc =< $Z ->
+ downcase(Rest, [Uc-$A+$a|Result]);
+downcase([C|Rest], Result) ->
+ downcase(Rest, [C|Result]);
+downcase([], Result) ->
+ lists:reverse(Result).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% html_convert_modules(TestSpec, Config) -> ok
+%% Isolate the modules affected by TestSpec and
+%% make sure they are converted to html.
+%%
+%% Errors are silently ignored.
+
+html_convert_modules(TestSpec, _Config) ->
+ Mods = html_isolate_modules(TestSpec),
+ html_convert_modules(Mods),
+ copy_html_files(get(test_server_dir), get(test_server_log_dir_base)).
+
+%% Retrieve a list of modules out of the test spec.
+
+html_isolate_modules(List) -> html_isolate_modules(List, sets:new()).
+
+html_isolate_modules([], Set) -> sets:to_list(Set);
+html_isolate_modules([{skip_case,_}|Cases], Set) ->
+ html_isolate_modules(Cases, Set);
+html_isolate_modules([{conf,_Ref,_Props,{Mod,_Func}}|Cases], Set) ->
+ html_isolate_modules(Cases, sets:add_element(Mod, Set));
+html_isolate_modules([{Mod,_Case}|Cases], Set) ->
+ html_isolate_modules(Cases, sets:add_element(Mod, Set));
+html_isolate_modules([{Mod,_Case,_Args}|Cases], Set) ->
+ html_isolate_modules(Cases, sets:add_element(Mod, Set)).
+
+%% Given a list of modules, convert each module's source code to HTML.
+
+html_convert_modules([Mod|Mods]) ->
+ case code:which(Mod) of
+ Path when is_list(Path) ->
+ SrcFile = filename:rootname(Path) ++ ".erl",
+ DestDir = get(test_server_dir),
+ Name = atom_to_list(Mod),
+ DestFile = filename:join(DestDir, downcase(Name) ++ ?src_listing_ext),
+ html_possibly_convert(SrcFile, DestFile),
+ html_convert_modules(Mods);
+ _Other -> ok
+ end;
+html_convert_modules([]) -> ok.
+
+%% Convert source code to HTML if possible and needed.
+
+html_possibly_convert(Src, Dest) ->
+ case file:read_file_info(Src) of
+ {ok,SInfo} ->
+ case file:read_file_info(Dest) of
+ {error,_Reason} -> % no dest file
+ erl2html2:convert(Src, Dest);
+ {ok,DInfo} when DInfo#file_info.mtime < SInfo#file_info.mtime ->
+ erl2html2:convert(Src, Dest);
+ {ok,_DInfo} -> ok % dest file up to date
+ end;
+ {error,_Reason} -> ok % no source code found
+ end.
+
+%% Copy all HTML files in InDir to OutDir.
+
+copy_html_files(InDir, OutDir) ->
+ Files = filelib:wildcard(filename:join(InDir, "*" ++ ?src_listing_ext)),
+ lists:foreach(fun (Src) -> copy_html_file(Src, OutDir) end, Files).
+
+copy_html_file(Src, DestDir) ->
+ Dest = filename:join(DestDir, filename:basename(Src)),
+ case file:read_file(Src) of
+ {ok,Bin} ->
+ ok = file:write_file(Dest, Bin);
+ {error,_Reason} ->
+ io:format("File ~p: read failed\n", [Src])
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% add_init_and_end_per_suite(TestSpec, Mod, Ref) -> NewTestSpec
+%%
+%% Expands TestSpec with an initial init_per_suite, and a final
+%% end_per_suite element, per each discovered suite in the list.
+
+add_init_and_end_per_suite([{make,_,_}=Case|Cases], LastMod, LastRef) ->
+ [Case|add_init_and_end_per_suite(Cases, LastMod, LastRef)];
+add_init_and_end_per_suite([{skip_case,{{Mod,all},_}}=Case|Cases], LastMod, LastRef)
+ when Mod =/= LastMod ->
+ {PreCases, NextMod, NextRef} =
+ do_add_end_per_suite_and_skip(LastMod, LastRef, Mod),
+ PreCases ++ [Case|add_init_and_end_per_suite(Cases, NextMod, NextRef)];
+add_init_and_end_per_suite([{skip_case,{{Mod,_},_}}=Case|Cases], LastMod, LastRef)
+ when Mod =/= LastMod ->
+ {PreCases, NextMod, NextRef} =
+ do_add_init_and_end_per_suite(LastMod, LastRef, Mod),
+ PreCases ++ [Case|add_init_and_end_per_suite(Cases, NextMod, NextRef)];
+add_init_and_end_per_suite([{skip_case,{conf,_,{Mod,_},_}}=Case|Cases], LastMod, LastRef)
+ when Mod =/= LastMod ->
+ {PreCases, NextMod, NextRef} =
+ do_add_init_and_end_per_suite(LastMod, LastRef, Mod),
+ PreCases ++ [Case|add_init_and_end_per_suite(Cases, NextMod, NextRef)];
+add_init_and_end_per_suite([{skip_case,_}=Case|Cases], LastMod, LastRef) ->
+ [Case|add_init_and_end_per_suite(Cases, LastMod, LastRef)];
+add_init_and_end_per_suite([{conf,_,_,{Mod,_}}=Case|Cases], LastMod, LastRef)
+ when Mod =/= LastMod ->
+ {PreCases, NextMod, NextRef} =
+ do_add_init_and_end_per_suite(LastMod, LastRef, Mod),
+ PreCases ++ [Case|add_init_and_end_per_suite(Cases, NextMod, NextRef)];
+add_init_and_end_per_suite([{conf,_,_,_}=Case|Cases], LastMod, LastRef) ->
+ [Case|add_init_and_end_per_suite(Cases, LastMod, LastRef)];
+add_init_and_end_per_suite([{Mod,_}=Case|Cases], LastMod, LastRef)
+ when Mod =/= LastMod ->
+ {PreCases, NextMod, NextRef} =
+ do_add_init_and_end_per_suite(LastMod, LastRef, Mod),
+ PreCases ++ [Case|add_init_and_end_per_suite(Cases, NextMod, NextRef)];
+add_init_and_end_per_suite([{Mod,_,_}=Case|Cases], LastMod, LastRef)
+ when Mod =/= LastMod ->
+ {PreCases, NextMod, NextRef} =
+ do_add_init_and_end_per_suite(LastMod, LastRef, Mod),
+ PreCases ++ [Case|add_init_and_end_per_suite(Cases, NextMod, NextRef)];
+add_init_and_end_per_suite([Case|Cases], LastMod, LastRef)->
+ [Case|add_init_and_end_per_suite(Cases, LastMod, LastRef)];
+add_init_and_end_per_suite([], _LastMod, undefined) ->
+ [];
+add_init_and_end_per_suite([], _LastMod, skipped_suite) ->
+ [];
+add_init_and_end_per_suite([], LastMod, LastRef) ->
+ [{conf,LastRef,[],{LastMod,end_per_suite}}].
+
+do_add_init_and_end_per_suite(LastMod, LastRef, Mod) ->
+ case code:is_loaded(Mod) of
+ false -> code:load_file(Mod);
+ _ -> ok
+ end,
+ {Init,NextMod,NextRef} =
+ case erlang:function_exported(Mod, init_per_suite, 1) of
+ true ->
+ Ref = make_ref(),
+ {[{conf,Ref,[],{Mod,init_per_suite}}],Mod,Ref};
+ false ->
+ {[],Mod,undefined}
+ end,
+ Cases =
+ if LastRef==undefined ->
+ Init;
+ LastRef==skipped_suite ->
+ Init;
+ true ->
+ %% Adding end_per_suite here without checking if the
+ %% function is actually exported. This is because a
+ %% conf case must have an end case - so if it doesn't
+ %% exist, it will only fail...
+ [{conf,LastRef,[],{LastMod,end_per_suite}}|Init]
+ end,
+ {Cases,NextMod,NextRef}.
+
+do_add_end_per_suite_and_skip(LastMod, LastRef, Mod) ->
+ case LastRef of
+ No when No==undefined ; No==skipped_suite ->
+ {[],Mod,skipped_suite};
+ _Ref ->
+ {[{conf,LastRef,[],{LastMod,end_per_suite}}],Mod,skipped_suite}
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% run_test_cases(TestSpec, Config, MultiplyTimetrap) -> exit(Result)
+%%
+%% If remote target, a socket connection is established.
+%% Runs the specified tests, then displays/logs the summary.
+
+run_test_cases(TestSpec, Config, MultiplyTimetrap) ->
+
+ maybe_open_job_sock(),
+
+ html_convert_modules(TestSpec, Config),
+
+ %%! For readable tracing...
+ %%! Config1 = [{data_dir,""},{priv_dir,""},{nodes,[]}],
+ %%! run_test_cases_loop(TestSpec, [[]], MultiplyTimetrap, [], []),
+
+ run_test_cases_loop(TestSpec, [Config], MultiplyTimetrap, [], []),
+
+ maybe_get_privdir(),
+
+ {AllSkippedN,UserSkipN,AutoSkipN,SkipStr} =
+ case get(test_server_skipped) of
+ {0,0} -> {0,0,0,""};
+ {US,AS} -> {US+AS,US,AS,io_lib:format(", ~w skipped", [US+AS])}
+ end,
+ OkN = get(test_server_ok),
+ FailedN = get(test_server_failed),
+ print(1, "TEST COMPLETE, ~w ok, ~w failed~s of ~w test cases\n",
+ [OkN,FailedN,SkipStr,OkN+FailedN+AllSkippedN]),
+ test_server_sup:framework_call(report, [tests_done,
+ {OkN,FailedN,{UserSkipN,AutoSkipN}}]),
+ print(major, "=finished ~s", [lists:flatten(timestamp_get(""))]),
+ print(major, "=failed ~p", [FailedN]),
+ print(major, "=successful ~p", [OkN]),
+ print(major, "=user_skipped ~p", [UserSkipN]),
+ print(major, "=auto_skipped ~p", [AutoSkipN]),
+ exit(test_suites_done).
+
+%% If the test is run at a remote target, this function sets up a socket
+%% communication with the target for handling this particular job.
+maybe_open_job_sock() ->
+ TI = get_target_info(),
+ case TI#target_info.where of
+ local ->
+ %% local target
+ test_server:init_purify();
+ MainSock ->
+ %% remote target
+ {ok,LSock} = gen_tcp:listen(0, [binary,
+ {reuseaddr,true},
+ {packet,4},
+ {active,false}]),
+ {ok,Port} = inet:port(LSock),
+ request(MainSock, {job,Port,get(test_server_name)}),
+ case gen_tcp:accept(LSock, ?ACCEPT_TIMEOUT) of
+ {ok,Sock} -> put(test_server_ctrl_job_sock, Sock);
+ {error,Reason} -> exit({no_contact,Reason})
+ end
+ end.
+
+%% If the test is run at a remote target, this function waits for a
+%% tar packet containing the privdir created by the test case.
+maybe_get_privdir() ->
+ case get(test_server_ctrl_job_sock) of
+ undefined ->
+ %% local target
+ ok;
+ Sock ->
+ %% remote target
+ request(Sock, job_done),
+ gen_tcp:close(Sock)
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% run_test_cases_loop(TestCases, Config, MultiplyTimetrap, Mode, Status) -> ok
+%% TestCases = [Test,...]
+%% Config = [[{Key,Val},...],...]
+%% MultiplyTimetrap = integer() | infinity
+%% Mode = [{Ref,[Prop,..],StartTime}]
+%% Ref = reference()
+%% Prop = {name,Name} | sequence | parallel |
+%% shuffle | {shuffle,Seed} |
+%% repeat | {repeat,N} |
+%% repeat_until_all_ok | {repeat_until_all_ok,N} |
+%% repeat_until_any_ok | {repeat_until_any_ok,N} |
+%% repeat_until_any_fail | {repeat_until_any_fail,N} |
+%% repeat_until_all_fail | {repeat_until_all_fail,N}
+%% Status = [{Ref,{{Ok,Skipped,Failed},CopiedCases}}]
+%% Ok = Skipped = Failed = [Case,...]
+%%
+%% Execute the TestCases under configuration Config. Config is a list
+%% of lists, where hd(Config) holds the config tuples for the current
+%% conf case and tl(Config) is the data for the higher level conf cases.
+%% Config data is "inherited" from top to nested conf cases, but
+%% never the other way around. if length(Config) == 1, Config contains
+%% only the initial config data for the suite.
+%%
+%% Test may be one of the following:
+%%
+%% {conf,Ref,Props,{Mod,Func}} Mod:Func is a configuration modification
+%% function, call it with the current configuration as argument. It will
+%% return a new configuration.
+%%
+%% {make,Ref,{Mod,Func,Args}} Mod:Func is a make function, and it is called
+%% with the given arguments. This function will *always* be called on the host
+%% - not on target.
+%%
+%% {Mod,Case} This is a normal test case. Determine the correct
+%% configuration, and insert {Mod,Case,Config} as head of the list,
+%% then reiterate.
+%%
+%% {Mod,Case,Args} A test case with predefined argument (usually a normal
+%% test case which just got a fresh configuration (see above)).
+%%
+%% {skip_case,{conf,Ref,Case,Comment}} An init conf case gets skipped
+%% by the user. This will also cause the end conf case to be skipped.
+%% Note that it is not possible to skip an end conf case directly (it
+%% can only be skipped indirectly by a skipped init conf case). The
+%% comment (which gets printed in the log files) describes why the case
+%% was skipped.
+%%
+%% {skip_case,{Case,Comment}} A normal test case skipped by the user.
+%% The comment (which gets printed in the log files) describes why the
+%% case was skipped.
+%%
+%% {auto_skip_case,{conf,Ref,Case,Comment},Mode} This is the result of
+%% an end conf case being automatically skipped due to a failing init
+%% conf case. It could also be a nested conf case that gets skipped
+%% because of a failed or skipped top level conf.
+%%
+%% {auto_skip_case,{Case,Comment},Mode} This is a normal test case which
+%% gets automatically skipped because of a failing init conf case or
+%% because of a failing previous test case in a sequence.
+%%
+%% -------------------------------------------------------------------
+%% Description of IO handling during execution of parallel test cases:
+%% -------------------------------------------------------------------
+%%
+%% A conf group can have an associated list of properties. If the
+%% parallel property is specified for a group, it means the test cases
+%% should be spawned and run in parallel rather than called sequentially
+%% (which is always the default mode). Test cases that execute in parallel
+%% also write to their respective minor log files in parallel. Printouts
+%% to common log files, such as the summary html file and the major log
+%% file on text format, still have to be processed sequentially. For this
+%% reason, the Mode argument specifies if a parallel group is currently
+%% being executed.
+%%
+%% A parallel test case process will always set the dictionary value
+%% 'test_server_common_io_handler' to the pid of the main (starting)
+%% process. With this value set, the print/3 function will send print
+%% messages to the main process instead of writing the data to file
+%% (only true for printouts to common log files).
+%%
+%% If a conf group nested under a parallel group in the test
+%% specification should be started, the 'test_server_common_io_handler'
+%% value gets set also on the main process. This causes all printouts
+%% to common files - both from parallel test cases and from cases
+%% executed by the main process - to all end up as messages in the
+%% inbox of the main process.
+%%
+%% During execution of a parallel group (or of a group nested under a
+%% parallel group), *any* new test case being started gets registered
+%% in a list saved in the dictionary with 'test_server_queued_io' as key.
+%% When the top level parallel group is finished (only then can we be
+%% sure all parallel test cases have finished and "reported in"), the
+%% list of test cases is traversed in order and printout messages from
+%% each process - including the main process - are handled in turn. See
+%% handle_test_case_io_and_status/0 for details.
+%%
+%% To be able to handle nested conf groups with different properties,
+%% the Mode argument specifies a list of {Ref,Properties} tuples.
+%% The head of the Mode list at any given time identifies the group
+%% currently being processed. The tail of the list identifies groups
+%% on higher level.
+%%
+%% -------------------------------------------------------------------
+%% Notes on parallel execution of test cases
+%% -------------------------------------------------------------------
+%%
+%% A group nested under a parallel group will start executing in
+%% parallel with previous (parallel) test cases (no matter what
+%% properties the nested group has). Test cases are however never
+%% executed in parallel with the start or end conf case of the same
+%% group! Because of this, the test_server_ctrl loop waits at
+%% the end conf of a group for all parallel cases to finish
+%% before the end conf case actually executes. This has the effect
+%% that it's only after a nested group has finished that any
+%% remaining parallel cases in the previous group get spawned (*).
+%% Example (all parallel cases):
+%%
+%% group1_init |---->
+%% group1_case1 | --------->
+%% group1_case2 | --------------------------------->
+%% group2_init | ---->
+%% group2_case1 | ------>
+%% group2_case2 | ---------->
+%% group2_end | --->
+%% group1_case3 (*)| ---->
+%% group1_case4 (*)| -->
+%% group1_end | --->
+%%
+
+run_test_cases_loop([{auto_skip_case,{Type,Ref,Case,Comment},SkipMode}|Cases],
+ Config, MultiplyTimetrap, Mode, Status) when Type==conf;
+ Type==make ->
+
+ file:set_cwd(filename:dirname(get(test_server_dir))),
+ CurrIOHandler = get(test_server_common_io_handler),
+ %% check and update the mode for test case execution and io msg handling
+ case {curr_ref(Mode),check_props(parallel, Mode)} of
+ {Ref,Ref} ->
+ case check_props(parallel, tl(Mode)) of
+ false ->
+ %% this is a skipped end conf for a top level parallel group,
+ %% buffered io can be flushed
+ handle_test_case_io_and_status(),
+ set_io_buffering(undefined),
+ {Mod,Func} = skip_case(auto, Ref, 0, Case, Comment, false, SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, tl(Mode),
+ delete_status(Ref, Status));
+ _ ->
+ %% this is a skipped end conf for a parallel group nested under a
+ %% parallel group (io buffering is active)
+ wait_for_cases(Ref),
+ {Mod,Func} = skip_case(auto, Ref, 0, Case, Comment, true, SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ case CurrIOHandler of
+ {Ref,_} ->
+ %% current_io_handler was set by start conf of this
+ %% group, so we can unset it now (no more io from main
+ %% process needs to be buffered)
+ set_io_buffering(undefined);
+ _ ->
+ ok
+ end,
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, tl(Mode),
+ delete_status(Ref, Status))
+ end;
+ {Ref,false} ->
+ %% this is a skipped end conf for a non-parallel group that's not
+ %% nested under a parallel group
+ {Mod,Func} = skip_case(auto, Ref, 0, Case, Comment, false, SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, tl(Mode),
+ delete_status(Ref, Status));
+ {Ref,_} ->
+ %% this is a skipped end conf for a non-parallel group nested under
+ %% a parallel group (io buffering is active)
+ {Mod,Func} = skip_case(auto, Ref, 0, Case, Comment, true, SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ case CurrIOHandler of
+ {Ref,_} ->
+ %% current_io_handler was set by start conf of this
+ %% group, so we can unset it now (no more io from main
+ %% process needs to be buffered)
+ set_io_buffering(undefined);
+ _ ->
+ ok
+ end,
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, tl(Mode),
+ delete_status(Ref, Status));
+ {_,false} ->
+ %% this is a skipped start conf for a group which is not nested
+ %% under a parallel group
+ {Mod,Func} = skip_case(auto, Ref, 0, Case, Comment, false, SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, [conf(Ref,[])|Mode], Status);
+ {_,Ref0} when is_reference(Ref0) ->
+ %% this is a skipped start conf for a group nested under a parallel group
+ %% and if this is the first nested group, io buffering must be activated
+ if CurrIOHandler == undefined ->
+ set_io_buffering({Ref,self()});
+ true ->
+ ok
+ end,
+ {Mod,Func} = skip_case(auto, Ref, 0, Case, Comment, true, SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, [conf(Ref,[])|Mode], Status)
+ end;
+
+run_test_cases_loop([{auto_skip_case,{Case,Comment},SkipMode}|Cases],
+ Config, MultiplyTimetrap, Mode, Status) ->
+ {Mod,Func} = skip_case(auto, undefined, get(test_server_case_num)+1, Case, Comment,
+ (undefined /= get(test_server_common_io_handler)), SkipMode),
+ test_server_sup:framework_call(report, [tc_auto_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, Mode,
+ update_status(skipped, Mod, Func, Status));
+
+run_test_cases_loop([{skip_case,{conf,Ref,Case,Comment}}|Cases0],
+ Config, MultiplyTimetrap, Mode, Status) ->
+ {Mod,Func} = skip_case(user, Ref, 0, Case, Comment,
+ (undefined /= get(test_server_common_io_handler))),
+ {Cases,Config1} =
+ case curr_ref(Mode) of
+ Ref ->
+ %% skipped end conf
+ {Cases0,tl(Config)};
+ _ ->
+ %% skipped start conf
+ {skip_cases_upto(Ref, Cases0, Comment, conf, Mode),Config}
+ end,
+ test_server_sup:framework_call(report, [tc_user_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config1, MultiplyTimetrap, Mode,
+ update_status(skipped, Mod, Func, Status));
+
+run_test_cases_loop([{skip_case,{Case,Comment}}|Cases],
+ Config, MultiplyTimetrap, Mode, Status) ->
+ {Mod,Func} = skip_case(user, undefined, get(test_server_case_num)+1, Case, Comment,
+ (undefined /= get(test_server_common_io_handler))),
+ test_server_sup:framework_call(report, [tc_user_skip,{?pl2a(Mod),Func,Comment}]),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, Mode,
+ update_status(skipped, Mod, Func, Status));
+
+%% a start *or* end conf case, wrapping test cases or other conf cases
+run_test_cases_loop([{conf,Ref,Props,{Mod,Func}}|_Cases]=Cs0,
+ Config, MultiplyTimetrap, Mode0, Status) ->
+
+ CurrIOHandler = get(test_server_common_io_handler),
+ %% check and update the mode for test case execution and io msg handling
+ {StartConf,Mode,IOHandler,ConfTime,Status1} =
+ case {curr_ref(Mode0),check_props(parallel, Mode0)} of
+ {Ref,Ref} ->
+ case check_props(parallel, tl(Mode0)) of
+ false ->
+ %% this is an end conf for a top level parallel group, collect
+ %% results from the test case processes and calc total time
+ OkSkipFail = handle_test_case_io_and_status(),
+ file:set_cwd(filename:dirname(get(test_server_dir))),
+ After = ?now,
+ Before = get(test_server_parallel_start_time),
+ Elapsed = elapsed_time(Before, After)/1000000,
+ put(test_server_total_time, Elapsed),
+ {false,tl(Mode0),undefined,Elapsed,
+ update_status(Ref, OkSkipFail, Status)};
+ _ ->
+ %% this is an end conf for a parallel group nested under a
+ %% parallel group (io buffering is active)
+ OkSkipFail = wait_for_cases(Ref),
+ queue_test_case_io(Ref, self(), 0, Mod, Func),
+ Elapsed = elapsed_time(conf_start(Ref, Mode0),?now)/1000000,
+ case CurrIOHandler of
+ {Ref,_} ->
+ %% current_io_handler was set by start conf of this
+ %% group, so we can unset it after this case (no
+ %% more io from main process needs to be buffered)
+ {false,tl(Mode0),undefined,Elapsed,
+ update_status(Ref, OkSkipFail, Status)};
+ _ ->
+ {false,tl(Mode0),CurrIOHandler,Elapsed,
+ update_status(Ref, OkSkipFail, Status)}
+ end
+ end;
+ {Ref,false} ->
+ %% this is an end conf for a non-parallel group that's not
+ %% nested under a parallel group, so no need to buffer io
+ {false,tl(Mode0),undefined,
+ elapsed_time(conf_start(Ref, Mode0),?now)/1000000, Status};
+ {Ref,_} ->
+ %% this is an end conf for a non-parallel group nested under
+ %% a parallel group (io buffering is active)
+ queue_test_case_io(Ref, self(), 0, Mod, Func),
+ Elapsed = elapsed_time(conf_start(Ref, Mode0),?now)/1000000,
+ case CurrIOHandler of
+ {Ref,_} ->
+ %% current_io_handler was set by start conf of this
+ %% group, so we can unset it after this case (no
+ %% more io from main process needs to be buffered)
+ {false,tl(Mode0),undefined,Elapsed,Status};
+ _ ->
+ {false,tl(Mode0),CurrIOHandler,Elapsed,Status}
+ end;
+ {_,false} ->
+ %% this is a start conf for a group which is not nested under a
+ %% parallel group, check if this case starts a new parallel group
+ case lists:member(parallel, Props) of
+ true ->
+ %% prepare for execution of parallel group
+ put(test_server_parallel_start_time, ?now),
+ put(test_server_queued_io, []);
+ false ->
+ ok
+ end,
+ {true,[conf(Ref,Props)|Mode0],undefined,0,Status};
+ {_,_Ref0} ->
+ %% this is a start conf for a group nested under a parallel group, the
+ %% parallel_start_time and parallel_test_cases values have already been set
+ queue_test_case_io(Ref, self(), 0, Mod, Func),
+ %% if this is the first nested group under a parallel group, io
+ %% buffering must be activated
+ IOHandler1 = if CurrIOHandler == undefined ->
+ IOH = {Ref,self()},
+ set_io_buffering(IOH),
+ IOH;
+ true ->
+ CurrIOHandler
+ end,
+ {true,[conf(Ref,Props)|Mode0],IOHandler1,0,Status}
+ end,
+
+ %% if this is a start conf we check if cases should be shuffled
+ {[_Conf|Cases1]=Cs1,Shuffle} =
+ if StartConf ->
+ case get_shuffle(Props) of
+ undefined ->
+ {Cs0,undefined};
+ {_,repeated} ->
+ %% if group is repeated, a new seed should not be set every
+ %% turn - last one is saved in dictionary
+ CurrSeed = get(test_server_curr_random_seed),
+ {shuffle_cases(Ref, Cs0, CurrSeed),{shuffle,CurrSeed}};
+ {_,Seed} ->
+ UseSeed=
+ %% Determine which seed to use by:
+ %% 1. check the TS_RANDOM_SEED env variable
+ %% 2. check random_seed in process state
+ %% 3. use value provided with shuffle option
+ %% 4. use now() values for seed
+ case os:getenv("TS_RANDOM_SEED") of
+ Undef when Undef == false ; Undef == "undefined" ->
+ case get(test_server_random_seed) of
+ undefined -> Seed;
+ TSRS -> TSRS
+ end;
+ NumStr ->
+ %% Ex: "123 456 789" or "123,456,789" -> {123,456,789}
+ list_to_tuple([list_to_integer(NS) ||
+ NS <- string:tokens(NumStr, [$ ,$:,$,])])
+ end,
+ {shuffle_cases(Ref, Cs0, UseSeed),{shuffle,UseSeed}}
+ end;
+ not StartConf ->
+ {Cs0,undefined}
+ end,
+
+ %% if this is a start conf we check if Props specifies repeat and if so
+ %% we copy the group and carry the copy until the end conf where we
+ %% decide to perform the repetition or not
+ {Repeating,Status2,Cases,ReportRepeatStop} =
+ if StartConf ->
+ case get_repeat(Props) of
+ undefined ->
+ %% we *must* have a status entry for every conf since we
+ %% will continously update status with test case results
+ %% without knowing the Ref (but update hd(Status))
+ {false,new_status(Ref, Status1),Cases1,?void_fun};
+ _ ->
+ {Copied,_} = copy_cases(Ref, make_ref(), Cs1),
+ {true,new_status(Ref, Copied, Status1),Cases1,?void_fun}
+ end;
+ not StartConf ->
+ RepVal = get_repeat(get_props(Mode0)),
+ ReportStop =
+ fun() ->
+ print(minor, "~n*** Stopping repeat operation ~w", [RepVal]),
+ print(1, "Stopping repeat operation ~w", [RepVal])
+ end,
+ CopiedCases = get_copied_cases(Status1),
+ EndStatus = delete_status(Ref, Status1),
+ %% check in Mode0 if this is a repeat conf
+ case RepVal of
+ undefined ->
+ {false,EndStatus,Cases1,?void_fun};
+ {repeat,_} ->
+ {true,EndStatus,CopiedCases++Cases1,?void_fun};
+ {repeat_until_all_ok,_} ->
+ {RestCs,Fun} = case get_tc_results(Status1) of
+ {_,_,[]} ->
+ {Cases1,ReportStop};
+ _ ->
+ {CopiedCases++Cases1,?void_fun}
+ end,
+ {true,EndStatus,RestCs,Fun};
+ {repeat_until_any_ok,_} ->
+ {RestCs,Fun} = case get_tc_results(Status1) of
+ {Ok,_,_} when length(Ok) > 0 ->
+ {Cases1,ReportStop};
+ _ ->
+ {CopiedCases++Cases1,?void_fun}
+ end,
+ {true,EndStatus,RestCs,Fun};
+ {repeat_until_any_fail,_} ->
+ {RestCs,Fun} = case get_tc_results(Status1) of
+ {_,_,Fails} when length(Fails) > 0 ->
+ {Cases1,ReportStop};
+ _ ->
+ {CopiedCases++Cases1,?void_fun}
+ end,
+ {true,EndStatus,RestCs,Fun};
+ {repeat_until_all_fail,_} ->
+ {RestCs,Fun} = case get_tc_results(Status1) of
+ {[],_,_} ->
+ {Cases1,ReportStop};
+ _ ->
+ {CopiedCases++Cases1,?void_fun}
+ end,
+ {true,EndStatus,RestCs,Fun}
+ end
+ end,
+
+ ReportAbortRepeat = fun(What) when Repeating ->
+ print(minor, "~n*** Aborting repeat operation "
+ "(configuration case ~w)", [What]),
+ print(1, "Aborting repeat operation "
+ "(configuration case ~w)", [What]);
+ (_) -> ok
+ end,
+
+ CfgProps = if StartConf ->
+ if Shuffle == undefined ->
+ [{tc_group_properties,Props}];
+ true ->
+ [{tc_group_properties,[Shuffle|delete_shuffle(Props)]}]
+ end;
+ not StartConf ->
+ {TcOk,TcSkip,TcFail} = get_tc_results(Status1),
+ [{tc_group_properties,get_props(Mode0)},
+ {tc_group_result,[{ok,TcOk},{skipped,TcSkip},{failed,TcFail}]}]
+ end,
+ ActualCfg =
+ update_config(hd(Config), [{priv_dir,get(test_server_priv_dir)},
+ {data_dir,get_data_dir(Mod)}] ++ CfgProps),
+ CurrMode = curr_mode(Ref, Mode0, Mode),
+
+ ConfCaseResult = run_test_case(Ref, 0, Mod, Func, [ActualCfg], skip_init, target,
+ MultiplyTimetrap, CurrMode),
+
+ case ConfCaseResult of
+ {_,NewCfg,_} when Func == init_per_suite, is_list(NewCfg) ->
+ %% check that init_per_suite returned data on correct format
+ case lists:filter(fun({_,_}) -> false;
+ (_) -> true end, NewCfg) of
+ [] ->
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, [NewCfg|Config],
+ MultiplyTimetrap, Mode, Status2);
+ Bad ->
+ print(minor, "~n*** ~p returned bad elements in Config: ~p.~n",
+ [Func,Bad]),
+ Reason = {failed,{Mod,init_per_suite,bad_return}},
+ Cases2 = skip_cases_upto(Ref, Cases, Reason, conf, CurrMode),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases2, Config, MultiplyTimetrap, Mode,
+ delete_status(Ref, Status2))
+ end;
+ {_,NewCfg,_} when StartConf, is_list(NewCfg) ->
+ print_conf_time(ConfTime),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, [NewCfg|Config], MultiplyTimetrap, Mode, Status2);
+ {_,{framework_error,{FwMod,FwFunc},Reason},_} ->
+ print(minor, "~n*** ~p failed in ~p. Reason: ~p~n", [FwMod,FwFunc,Reason]),
+ print(1, "~p failed in ~p. Reason: ~p~n", [FwMod,FwFunc,Reason]),
+ exit(framework_error);
+ {_,Fail,_} when element(1,Fail) == 'EXIT';
+ element(1,Fail) == timetrap_timeout;
+ element(1,Fail) == failed ->
+ {Cases2,Config1} =
+ if StartConf ->
+ ReportAbortRepeat(failed),
+ print(minor, "~n*** ~p failed.~n"
+ " Skipping all cases.", [Func]),
+ Reason = {failed,{Mod,Func,Fail}},
+ {skip_cases_upto(Ref, Cases, Reason, conf, CurrMode),Config};
+ not StartConf ->
+ ReportRepeatStop(),
+ print_conf_time(ConfTime),
+ {Cases,tl(Config)}
+ end,
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases2, Config1, MultiplyTimetrap, Mode,
+ delete_status(Ref, Status2));
+ {died,Why,_} when Func == init_per_suite ->
+ print(minor, "~n*** Unexpected exit during init_per_suite.~n", []),
+ Reason = {failed,{Mod,init_per_suite,Why}},
+ Cases2 = skip_cases_upto(Ref, Cases, Reason, conf, CurrMode),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases2, Config, MultiplyTimetrap, Mode,
+ delete_status(Ref, Status2));
+ {_,{Skip,Reason},_} when StartConf and ((Skip==skip) or (Skip==skipped)) ->
+ ReportAbortRepeat(skipped),
+ print(minor, "~n*** ~p skipped.~n"
+ " Skipping all cases.", [Func]),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(skip_cases_upto(Ref, Cases, Reason, conf, CurrMode),
+ Config, MultiplyTimetrap, Mode,
+ delete_status(Ref, Status2));
+ {_,{skip_and_save,Reason,_SavedConfig},_} when StartConf ->
+ ReportAbortRepeat(skipped),
+ print(minor, "~n*** ~p skipped.~n"
+ " Skipping all cases.", [Func]),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(skip_cases_upto(Ref, Cases, Reason, conf, CurrMode),
+ Config, MultiplyTimetrap, Mode,
+ delete_status(Ref, Status2));
+ {_,_Other,_} when Func == init_per_suite ->
+ print(minor, "~n*** init_per_suite failed to return a Config list.~n", []),
+ Reason = {failed,{Mod,init_per_suite,bad_return}},
+ Cases2 = skip_cases_upto(Ref, Cases, Reason, conf, CurrMode),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases2, Config, MultiplyTimetrap, Mode,
+ delete_status(Ref, Status2));
+ {_,_Other,_} when StartConf ->
+ print_conf_time(ConfTime),
+ set_io_buffering(IOHandler),
+ ReportRepeatStop(),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, [hd(Config)|Config], MultiplyTimetrap,
+ Mode, Status2);
+
+ {_,_EndConfRetVal,Opts} ->
+ %% check if return_group_result is set (ok, skipped or failed) and
+ %% if so return the value to the group "above" so that result may be
+ %% used for evaluating repeat_until_*
+ Status3 =
+ case lists:keysearch(return_group_result, 1, Opts) of
+ {value,{_,GroupResult}} ->
+ update_status(GroupResult, group_result, Func,
+ delete_status(Ref, Status2));
+ false ->
+ delete_status(Ref, Status2)
+ end,
+ print_conf_time(ConfTime),
+ ReportRepeatStop(),
+ set_io_buffering(IOHandler),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, tl(Config), MultiplyTimetrap, Mode, Status3)
+ end;
+
+run_test_cases_loop([{make,Ref,{Mod,Func,Args}}|Cases0], Config, MultiplyTimetrap, Mode, Status) ->
+ case run_test_case(Ref, 0, Mod, Func, Args, skip_init, host, MultiplyTimetrap) of
+ {_,Why={'EXIT',_},_} ->
+ print(minor, "~n*** ~p failed.~n"
+ " Skipping all cases.", [Func]),
+ Reason = {failed,{Mod,Func,Why}},
+ Cases = skip_cases_upto(Ref, Cases0, Reason, conf, Mode),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, Mode, Status);
+ {_,_Whatever,_} ->
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases0, Config, MultiplyTimetrap, Mode, Status)
+ end;
+
+run_test_cases_loop([{conf,_Ref,_Props,_X}=Conf|_Cases0],
+ Config, _MultiplyTimetrap, _Mode, _Status) ->
+ erlang:error(badarg, [Conf,Config]);
+
+run_test_cases_loop([{Mod,Case}|Cases], Config, MultiplyTimetrap, Mode, Status) ->
+ ActualCfg =
+ update_config(hd(Config), [{priv_dir,get(test_server_priv_dir)},
+ {data_dir,get_data_dir(Mod)}]),
+ run_test_cases_loop([{Mod,Case,[ActualCfg]}|Cases], Config,
+ MultiplyTimetrap, Mode, Status);
+
+run_test_cases_loop([{Mod,Func,Args}|Cases], Config, MultiplyTimetrap, Mode, Status) ->
+ Num = put(test_server_case_num, get(test_server_case_num)+1),
+ %% check the current execution mode and save info about the case if
+ %% detected that printouts to common log files is handled later
+ case check_prop(parallel, Mode) of
+ false ->
+ case get(test_server_common_io_handler) of
+ undefined ->
+ %% io printouts are written to straight to file
+ ok;
+ _ ->
+ %% io messages are buffered, put test case in queue
+ queue_test_case_io(undefined, self(), Num+1, Mod, Func)
+ end;
+ _ ->
+ ok
+ end,
+ case run_test_case(undefined, Num+1, Mod, Func, Args,
+ run_init, target, MultiplyTimetrap, Mode) of
+ %% callback to framework module failed, exit immediately
+ {_,{framework_error,{FwMod,FwFunc},Reason},_} ->
+ print(minor, "~n*** ~p failed in ~p. Reason: ~p~n", [FwMod,FwFunc,Reason]),
+ print(1, "~p failed in ~p. Reason: ~p~n", [FwMod,FwFunc,Reason]),
+ stop_minor_log_file(),
+ exit(framework_error);
+ %% sequential execution of test case finished
+ {Time,RetVal,_} ->
+ {Failed,Status1} =
+ case Time of
+ died ->
+ {true,update_status(failed, Mod, Func, Status)};
+ _ when is_tuple(RetVal) ->
+ case element(1, RetVal) of
+ R when R=='EXIT'; R==failed ->
+ {true,update_status(failed, Mod, Func, Status)};
+ R when R==skip; R==skipped ->
+ {false,update_status(skipped, Mod, Func, Status)};
+ _ ->
+ {false,update_status(ok, Mod, Func, Status)}
+ end;
+ _ ->
+ {false,update_status(ok, Mod, Func, Status)}
+ end,
+ case check_prop(sequence, Mode) of
+ false ->
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, Mode, Status1);
+ Ref ->
+ %% the case is in a sequence; we must check the result and
+ %% determine if the following cases should run or be skipped
+ if not Failed -> % proceed with next case
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, Mode, Status1);
+ true -> % skip rest of cases in sequence
+ print(minor, "~n*** ~p failed.~n"
+ " Skipping all other cases in sequence.", [Func]),
+ Reason = {failed,{Mod,Func}},
+ Cases2 = skip_cases_upto(Ref, Cases, Reason, tc, Mode),
+ stop_minor_log_file(),
+ run_test_cases_loop(Cases2, Config, MultiplyTimetrap, Mode, Status1)
+ end
+ end;
+ %% the test case is being executed in parallel with the main process (and
+ %% other test cases) and Pid is the dedicated process executing the case
+ Pid ->
+ %% io from Pid will be buffered in the main process inbox and handled
+ %% later, so we have to save info about the case
+ queue_test_case_io(undefined, Pid, Num+1, Mod, Func),
+ run_test_cases_loop(Cases, Config, MultiplyTimetrap, Mode, Status)
+ end;
+
+%% TestSpec processing finished
+run_test_cases_loop([], _Config, _MultiplyTimetrap, _, _) ->
+ ok.
+
+%%--------------------------------------------------------------------
+%% various help functions
+
+new_status(Ref, Status) ->
+ [{Ref,{{[],[],[]},[]}} | Status].
+
+new_status(Ref, CopiedCases, Status) ->
+ [{Ref,{{[],[],[]},CopiedCases}} | Status].
+
+delete_status(Ref, Status) ->
+ lists:keydelete(Ref, 1, Status).
+
+update_status(ok, Mod, Func, [{Ref,{{Ok,Skip,Fail},Cs}} | Status]) ->
+ [{Ref,{{Ok++[{Mod,Func}],Skip,Fail},Cs}} | Status];
+
+update_status(skipped, Mod, Func, [{Ref,{{Ok,Skip,Fail},Cs}} | Status]) ->
+ [{Ref,{{Ok,Skip++[{Mod,Func}],Fail},Cs}} | Status];
+
+update_status(failed, Mod, Func, [{Ref,{{Ok,Skip,Fail},Cs}} | Status]) ->
+ [{Ref,{{Ok,Skip,Fail++[{Mod,Func}]},Cs}} | Status];
+
+update_status(_, _, _, []) ->
+ [].
+
+update_status(Ref, {Ok,Skip,Fail}, [{Ref,{{Ok0,Skip0,Fail0},Cs}} | Status]) ->
+ [{Ref,{{Ok0++Ok,Skip0++Skip,Fail0++Fail},Cs}} | Status].
+
+get_copied_cases([{_,{_,Cases}} | _Status]) ->
+ Cases.
+
+get_tc_results([{_,{OkSkipFail,_}} | _Status]) ->
+ OkSkipFail.
+
+conf(Ref, Props) ->
+ {Ref,Props,?now}.
+
+curr_ref([{Ref,_Props,_}|_]) ->
+ Ref;
+curr_ref([]) ->
+ undefined.
+
+curr_mode(Ref, Mode0, Mode1) ->
+ case curr_ref(Mode1) of
+ Ref -> Mode1;
+ _ -> Mode0
+ end.
+
+get_props([{_,Props,_} | _]) ->
+ Props;
+get_props([]) ->
+ [].
+
+check_prop(_Attrib, []) ->
+ false;
+check_prop(Attrib, [{Ref,Props,_}|_]) ->
+ case lists:member(Attrib, Props) of
+ true -> Ref;
+ false -> false
+ end.
+
+check_props(Attrib, Mode) ->
+ case [R || {R,Ps,_} <- Mode, lists:member(Attrib, Ps)] of
+ [] -> false;
+ [Ref|_] -> Ref
+ end.
+
+get_name([{_Ref,Props,_}|_]) ->
+ proplists:get_value(name, Props);
+get_name([]) ->
+ undefined.
+
+conf_start(Ref, Mode) ->
+ case lists:keysearch(Ref, 1, Mode) of
+ {value,{_,_,T}} -> T;
+ false -> 0
+ end.
+
+get_data_dir(Mod) ->
+ case code:which(Mod) of
+ non_existing ->
+ print(12, "The module ~p is not loaded", [Mod]),
+ [];
+ FullPath ->
+ filename:dirname(FullPath) ++ "/" ++ cast_to_list(Mod) ++
+ ?data_dir_suffix
+ end.
+
+print_conf_time(0) ->
+ ok;
+print_conf_time(ConfTime) ->
+ print(major, "=group_time ~.3fs", [ConfTime]),
+ print(minor, "~n=== Total execution time of group: ~.3fs~n", [ConfTime]).
+
+print_props(_, []) ->
+ ok;
+print_props(true, Props) ->
+ print(major, "=group_props ~p", [Props]),
+ print(minor, "Group properties: ~p~n", [Props]);
+print_props(_, _) ->
+ ok.
+
+%% repeat N times: {repeat,N}
+%% repeat N times or until all successful: {repeat_until_all_ok,N}
+%% repeat N times or until at least one successful: {repeat_until_any_ok,N}
+%% repeat N times or until at least one case fails: {repeat_until_any_fail,N}
+%% repeat N times or until all fails: {repeat_until_all_fail,N}
+%% N = integer() | forever
+get_repeat(Props) ->
+ get_prop([repeat,repeat_until_all_ok,repeat_until_any_ok,
+ repeat_until_any_fail,repeat_until_all_fail], forever, Props).
+
+update_repeat(Props) ->
+ case get_repeat(Props) of
+ undefined ->
+ Props;
+ {RepType,N} ->
+ Props1 =
+ if N == forever ->
+ [{RepType,N}|lists:keydelete(RepType, 1, Props)];
+ N < 2 ->
+ lists:keydelete(RepType, 1, Props);
+ N >= 2 ->
+ [{RepType,N-1}|lists:keydelete(RepType, 1, Props)]
+ end,
+ %% if shuffle is used in combination with repeat, a new
+ %% seed shouldn't be set every new turn
+ case get_shuffle(Props1) of
+ undefined ->
+ Props1;
+ _ ->
+ [{shuffle,repeated}|delete_shuffle(Props1)]
+ end
+ end.
+
+get_shuffle(Props) ->
+ get_prop([shuffle], ?now, Props).
+
+delete_shuffle(Props) ->
+ delete_prop([shuffle], Props).
+
+%% Return {Item,Value} if found, else if Item alone
+%% is found, return {Item,Default}
+get_prop([Item|Items], Default, Props) ->
+ case lists:keysearch(Item, 1, Props) of
+ {value,R} ->
+ R;
+ false ->
+ case lists:member(Item, Props) of
+ true ->
+ {Item,Default};
+ false ->
+ get_prop(Items, Default, Props)
+ end
+ end;
+get_prop([], _Def, _Props) ->
+ undefined.
+
+delete_prop([Item|Items], Props) ->
+ Props1 = lists:delete(Item, lists:keydelete(Item, 1, Props)),
+ delete_prop(Items, Props1);
+delete_prop([], Props) ->
+ Props.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% shuffle_cases(Ref, Cases, Seed) -> Cases1
+%%
+%% Shuffles the order of Cases.
+
+shuffle_cases(Ref, Cases, undefined) ->
+ shuffle_cases(Ref, Cases, ?now);
+
+shuffle_cases(Ref, [{conf,Ref,_,_}=Start | Cases], Seed) ->
+ {N,CasesToShuffle,Rest} = cases_to_shuffle(Ref, Cases),
+ ShuffledCases = random_order(N, random:uniform_s(N, Seed), CasesToShuffle, []),
+ [Start|ShuffledCases] ++ Rest.
+
+cases_to_shuffle(Ref, Cases) ->
+ cases_to_shuffle(Ref, Cases, 1, []).
+
+cases_to_shuffle(Ref, [{conf,Ref,_,_} | _]=Cs, N, Ix) -> % end
+ {N-1,Ix,Cs};
+cases_to_shuffle(Ref, [{skip_case,{_,Ref,_,_}} | _]=Cs, N, Ix) -> % end
+ {N-1,Ix,Cs};
+
+cases_to_shuffle(Ref, [{conf,Ref1,_,_}=C | Cs], N, Ix) -> % nested group
+ {Cs1,Rest} = get_subcases(Ref1, Cs, []),
+ cases_to_shuffle(Ref, Rest, N+1, [{N,[C|Cs1]} | Ix]);
+cases_to_shuffle(Ref, [{skip_case,{_,Ref1,_,_}}=C | Cs], N, Ix) -> % nested group
+ {Cs1,Rest} = get_subcases(Ref1, Cs, []),
+ cases_to_shuffle(Ref, Rest, N+1, [{N,[C|Cs1]} | Ix]);
+
+cases_to_shuffle(Ref, [C | Cs], N, Ix) ->
+ cases_to_shuffle(Ref, Cs, N+1, [{N,[C]} | Ix]).
+
+get_subcases(SubRef, [{conf,SubRef,_,_}=C | Cs], SubCs) ->
+ {lists:reverse([C|SubCs]),Cs};
+get_subcases(SubRef, [{skip_case,{_,SubRef,_,_}}=C | Cs], SubCs) ->
+ {lists:reverse([C|SubCs]),Cs};
+get_subcases(SubRef, [C|Cs], SubCs) ->
+ get_subcases(SubRef, Cs, [C|SubCs]).
+
+random_order(1, {_Pos,Seed}, [{_Ix,CaseOrGroup}], Shuffled) ->
+ %% save current seed to be used if test cases are repeated
+ put(test_server_curr_random_seed, Seed),
+ Shuffled++CaseOrGroup;
+random_order(N, {Pos,NewSeed}, IxCases, Shuffled) ->
+ {First,[{_Ix,CaseOrGroup}|Rest]} = lists:split(Pos-1, IxCases),
+ random_order(N-1, random:uniform_s(N-1, NewSeed),
+ First++Rest, Shuffled++CaseOrGroup).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% skip_case(Type, Ref, CaseNum, Case, Comment, SendSync) -> {Mod,Func}
+%%
+%% Prints info about a skipped case in the major and html log files.
+%% SendSync determines if start and finished messages must be sent so
+%% that the printouts can be buffered and handled in order with io from
+%% parallel processes.
+
+skip_case(Type, Ref, CaseNum, Case, Comment, SendSync) ->
+ skip_case(Type, Ref, CaseNum, Case, Comment, SendSync, []).
+
+skip_case(Type, Ref, CaseNum, Case, Comment, SendSync, Mode) ->
+ MF = {Mod,Func} = case Case of
+ {M,F,_A} -> {M,F};
+ {M,F} -> {M,F}
+ end,
+ if SendSync ->
+ queue_test_case_io(Ref, self(), CaseNum, Mod, Func),
+ self() ! {started,Ref,self(),CaseNum,Mod,Func},
+ skip_case1(Type, CaseNum, Mod, Func, Comment, Mode),
+ self() ! {finished,Ref,self(),CaseNum,Mod,Func,skipped,{0,skipped,[]}};
+ not SendSync ->
+ skip_case1(Type, CaseNum, Mod, Func, Comment, Mode)
+ end,
+ MF.
+
+skip_case1(Type, CaseNum, Mod, Func, Comment, Mode) ->
+ {{Col0,Col1},_} = get_font_style((CaseNum > 0), Mode),
+ ResultCol = if Type == auto -> "#ffcc99";
+ Type == user -> "#ff9933"
+ end,
+
+ Comment1 = reason_to_string(Comment),
+
+ print(major, "~n=case ~p:~p", [Mod,Func]),
+ print(major, "=started ~s", [lists:flatten(timestamp_get(""))]),
+ print(major, "=result skipped: ~s", [Comment1]),
+ print(2,"*** Skipping test case #~w ~p ***", [CaseNum,{Mod,Func}]),
+ print(html,
+ "<tr valign=top>"
+ "<td>" ++ Col0 ++ "~s" ++ Col1 ++ "</td>"
+ "<td>" ++ Col0 ++ "~p" ++ Col1 ++ "</td>"
+ "<td>" ++ Col0 ++ "~p" ++ Col1 ++ "</td>"
+ "<td>" ++ Col0 ++ "< >" ++ Col1 ++ "</td>"
+ "<td>" ++ Col0 ++ "0.000s" ++ Col1 ++ "</td>"
+ "<td><font color=\"~s\">SKIPPED</font></td>"
+ "<td>~s</td></tr>\n",
+ [num2str(CaseNum),Mod,Func,ResultCol,Comment1]),
+ if CaseNum > 0 ->
+ {US,AS} = get(test_server_skipped),
+ case Type of
+ user -> put(test_server_skipped, {US+1,AS});
+ auto -> put(test_server_skipped, {US,AS+1})
+ end,
+ put(test_server_case_num, CaseNum);
+ true -> % conf
+ ok
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% skip_cases_upto(Ref, Cases, Reason, Origin, Mode) -> Cases1
+%%
+%% Mark all cases tagged with Ref as skipped.
+
+skip_cases_upto(Ref, Cases, Reason, Origin, Mode) ->
+ {_,Modified,Rest} = modify_cases_upto(Ref, {skip,Reason,Origin,Mode}, Cases),
+ Modified++Rest.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% copy_cases(OrigRef, NewRef, Cases) -> Cases1
+%%
+%% Copy the test cases marked with OrigRef and tag the copies with NewRef.
+%% The start conf case copy will also get its repeat property updated.
+
+copy_cases(OrigRef, NewRef, Cases) ->
+ {Original,Altered,Rest} = modify_cases_upto(OrigRef, {copy,NewRef}, Cases),
+ {Altered,Original++Altered++Rest}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% modify_cases_upto(Ref, ModOp, Cases) -> {Original,Altered,Remaining}
+%%
+%% ModOp = {skip,Reason,Origin,Mode} | {copy,NewRef}
+%% Origin = conf | tc
+%%
+%% Modifies Cases according to ModOp and returns the original elements,
+%% the modified versions of these elements and the remaining (untouched)
+%% cases.
+
+modify_cases_upto(Ref, ModOp, Cases) ->
+ {Original,Altered,Rest} = modify_cases_upto(Ref, ModOp, Cases, [], []),
+ {lists:reverse(Original),lists:reverse(Altered),Rest}.
+
+%% first case of a copy operation is the start conf
+modify_cases_upto(Ref, {copy,NewRef}=Op, [{conf,Ref,Props,MF}=C|T], Orig, Alt) ->
+ modify_cases_upto(Ref, Op, T, [C|Orig], [{conf,NewRef,update_repeat(Props),MF}|Alt]);
+
+modify_cases_upto(Ref, ModOp, Cases, Orig, Alt) ->
+ %% we need to check if there's an end conf case with the
+ %% same ref in the list, if not, this *is* an end conf case
+ case lists:any(fun({_,R,_,_}) when R == Ref -> true;
+ ({_,R,_}) when R == Ref -> true;
+ ({skip_case,{_,R,_,_}}) when R == Ref -> true;
+ (_) -> false
+ end, Cases) of
+ true ->
+ modify_cases_upto1(Ref, ModOp, Cases, Orig, Alt);
+ false ->
+ {[],[],Cases}
+ end.
+
+%% next case is a conf with same ref, must be end conf = we're done
+modify_cases_upto1(Ref, {skip,Reason,conf,Mode}, [{conf,Ref,_Props,MF}|T], Orig, Alt) ->
+ {Orig,[{auto_skip_case,{conf,Ref,MF,Reason},Mode}|Alt],T};
+modify_cases_upto1(Ref, {copy,NewRef}, [{conf,Ref,Props,MF}=C|T], Orig, Alt) ->
+ {[C|Orig],[{conf,NewRef,update_repeat(Props),MF}|Alt],T};
+
+%% we've skipped all remaining cases in a sequence
+modify_cases_upto1(Ref, {skip,_,tc,_}, [{conf,Ref,_Props,_MF}|_]=Cs, Orig, Alt) ->
+ {Orig,Alt,Cs};
+
+%% next is a make case
+modify_cases_upto1(Ref, {skip,Reason,_,Mode}, [{make,Ref,MF}|T], Orig, Alt) ->
+ {Orig,[{auto_skip_case,{make,Ref,MF,Reason},Mode}|Alt],T};
+modify_cases_upto1(Ref, {copy,NewRef}, [{make,Ref,MF}=M|T], Orig, Alt) ->
+ {[M|Orig],[{make,NewRef,MF}|Alt],T};
+
+%% next case is a user skipped end conf with the same ref = we're done
+modify_cases_upto1(Ref, {skip,Reason,_,Mode}, [{skip_case,{Type,Ref,MF,_Cmt}}|T], Orig, Alt) ->
+ {Orig,[{auto_skip_case,{Type,Ref,MF,Reason},Mode}|Alt],T};
+modify_cases_upto1(Ref, {copy,NewRef}, [{skip_case,{Type,Ref,MF,Cmt}}=C|T], Orig, Alt) ->
+ {[C|Orig],[{skip_case,{Type,NewRef,MF,Cmt}}|Alt],T};
+
+%% next is a skip_case, could be one test case or 'all' in suite, we must proceed
+modify_cases_upto1(Ref, ModOp, [{skip_case,{_F,_Cmt}}=MF|T], Orig, Alt) ->
+ modify_cases_upto1(Ref, ModOp, T, [MF|Orig], [MF|Alt]);
+
+%% next is a normal case (possibly in a sequence), mark as skipped, or copy, and proceed
+modify_cases_upto1(Ref, {skip,Reason,_,Mode}=Op, [{_M,_F}=MF|T], Orig, Alt) ->
+ modify_cases_upto1(Ref, Op, T, Orig, [{auto_skip_case,{MF,Reason},Mode}|Alt]);
+modify_cases_upto1(Ref, CopyOp, [{_M,_F}=MF|T], Orig, Alt) ->
+ modify_cases_upto1(Ref, CopyOp, T, [MF|Orig], [MF|Alt]);
+
+%% next is some other case, ignore or copy
+modify_cases_upto1(Ref, {skip,_,_,_}=Op, [_|T], Orig, Alt) ->
+ modify_cases_upto1(Ref, Op, T, Orig, Alt);
+modify_cases_upto1(Ref, CopyOp, [C|T], Orig, Alt) ->
+ modify_cases_upto1(Ref, CopyOp, T, [C|Orig], [C|Alt]).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% set_io_buffering(IOHandler) -> PrevIOHandler
+%%
+%% Save info about current process (always the main process) buffering
+%% io printout messages from parallel test case processes (*and* possibly
+%% also the main process). If the value is the default 'undefined',
+%% io is not buffered but printed directly to file (see print/3).
+
+set_io_buffering(IOHandler) ->
+ put(test_server_common_io_handler, IOHandler).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% queue_test_case_io(Pid, Num, Mod, Func) -> ok
+%%
+%% Save info about test case that gets its io buffered. This can
+%% be a parallel test case or it can be a test case (conf or normal)
+%% that belongs to a group nested under a parallel group. The queue
+%% is processed after io buffering is disabled. See run_test_cases_loop/4
+%% and handle_test_case_io_and_status/0 for more info.
+
+queue_test_case_io(Ref, Pid, Num, Mod, Func) ->
+ Entry = {Ref,Pid,Num,Mod,Func},
+ %% the order of the test cases is very important!
+ put(test_server_queued_io,
+ get(test_server_queued_io)++[Entry]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% wait_for_cases(Ref) -> {Ok,Skipped,Failed}
+%%
+%% At the end of a nested parallel group, we have to wait for the test
+%% cases to terminate before we can go on (since test cases never execute
+%% in parallel with the end conf case of the group). When a top level
+%% parallel group is finished, buffered io messages must be handled and
+%% this is taken care of by handle_test_case_io_and_status/0.
+
+wait_for_cases(Ref) ->
+ case get(test_server_queued_io) of
+ [] ->
+ {[],[],[]};
+ Cases ->
+ [_Start|TCs] =
+ lists:dropwhile(fun({R,_,_,_,_}) when R == Ref -> false;
+ (_) -> true
+ end, Cases),
+ wait_and_resend(Ref, TCs, [],[],[])
+ end.
+
+wait_and_resend(Ref, [{OtherRef,_,0,_,_}|Ps],
+ Ok,Skip,Fail) when is_reference(OtherRef),
+ OtherRef /= Ref ->
+ %% ignore cases that belong to nested group
+ Ps1 = rm_cases_upto(OtherRef, Ps),
+ wait_and_resend(Ref, Ps1, Ok,Skip,Fail);
+
+wait_and_resend(Ref, [{_,CurrPid,CaseNum,Mod,Func}|Ps] = Cases, Ok,Skip,Fail) ->
+ receive
+ {finished,_Ref,CurrPid,CaseNum,Mod,Func,Result,_RetVal} = Msg ->
+ %% resend message to main process so that it can be used
+ %% to handle buffered io messages later
+ self() ! Msg,
+ MF = {Mod,Func},
+ {Ok1,Skip1,Fail1} =
+ case Result of
+ ok -> {[MF|Ok],Skip,Fail};
+ skipped -> {Ok,[MF|Skip],Fail};
+ failed -> {Ok,Skip,[MF|Fail]}
+ end,
+ wait_and_resend(Ref, Ps, Ok1,Skip1,Fail1);
+ {'EXIT',CurrPid,Reason} when Reason /= normal ->
+ %% unexpected termination of test case process
+ {value,{_,_,CaseNum,Mod,Func}} = lists:keysearch(CurrPid, 2, Cases),
+ print(1, "Error! Process for test case #~p (~p:~p) died! Reason: ~p",
+ [CaseNum, Mod, Func, Reason]),
+ exit({unexpected_termination,{CaseNum,Mod,Func},{CurrPid,Reason}})
+ end;
+
+wait_and_resend(_, [], Ok,Skip,Fail) ->
+ {lists:reverse(Ok),lists:reverse(Skip),lists:reverse(Fail)}.
+
+rm_cases_upto(Ref, [{Ref,_,0,_,_}|Ps]) ->
+ Ps;
+rm_cases_upto(Ref, [_|Ps]) ->
+ rm_cases_upto(Ref, Ps).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% handle_test_case_io_and_status() -> [Ok,Skipped,Failed}
+%%
+%% Each parallel test case process prints to its own minor log file during
+%% execution. The common log files (major, html etc) must however be
+%% written to sequentially. The test case processes send print requests
+%% to the main (starting) process (the same process executing
+%% run_test_cases_loop/4), which handles these requests in the same
+%% order that the test case processes were started.
+%%
+%% An io session is always started with a {started,Ref,Pid,Num,Mod,Func}
+%% message and terminated with {finished,Ref,Pid,Num,Mod,Func,Result,RetVal}.
+%% The result shipped with the finished message from a parallel process
+%% is used to update status data of the current test run. An 'EXIT'
+%% message from each parallel test case process (after finishing and
+%% terminating) is also received and handled here.
+%%
+%% During execution of a parallel group, any cases (conf or normal)
+%% belonging to a nested group will also get its io printouts buffered.
+%% This is necessary to get the major and html log files written in
+%% correct sequence. This function handles also the print messages
+%% generated by nested group cases that have been executed sequentially
+%% by the main process (note that these cases do not generate 'EXIT'
+%% messages, only 'start', 'print' and 'finished' messages).
+%%
+%% See the header comment for run_test_cases_loop/4 for more
+%% info about IO handling.
+%%
+%% Note: It is important that the type of messages handled here
+%% do not get consumated by test_server:run_test_case_msgloop/5
+%% during the test case execution (e.g. in the catch clause of
+%% the receive)!
+
+handle_test_case_io_and_status() ->
+ case get(test_server_queued_io) of
+ [] ->
+ {[],[],[]};
+ Cases ->
+ %% Cases = [{Ref,Pid,CaseNum,Mod,Func} | ...]
+ Result = handle_io_and_exit_loop([], Cases, [],[],[]),
+ Main = self(),
+ %% flush normal exit messages
+ lists:foreach(fun({_,Pid,_,_,_}) when Pid /= Main ->
+ receive
+ {'EXIT',Pid,normal} -> ok
+ after
+ 1000 -> ok
+ end;
+ (_) ->
+ ok
+ end, Cases),
+ Result
+ end.
+
+%% Handle cases (without Ref) that belong to the top parallel group (i.e. when Refs = [])
+handle_io_and_exit_loop([], [{undefined,CurrPid,CaseNum,Mod,Func}|Ps] = Cases, Ok,Skip,Fail) ->
+ %% retreive the start message for the current io session (= testcase)
+ receive
+ {started,_,CurrPid,CaseNum,Mod,Func} ->
+ {Ok1,Skip1,Fail1} =
+ case handle_io_and_exits(self(), CurrPid, CaseNum, Mod, Func, Cases) of
+ {ok,MF} -> {[MF|Ok],Skip,Fail};
+ {skipped,MF} -> {Ok,[MF|Skip],Fail};
+ {failed,MF} -> {Ok,Skip,[MF|Fail]}
+ end,
+ handle_io_and_exit_loop([], Ps, Ok1,Skip1,Fail1)
+ after
+ 1000 ->
+ exit({testcase_failed_to_start,Mod,Func})
+ end;
+
+%% Handle cases that belong to groups nested under top parallel group
+handle_io_and_exit_loop(Refs, [{Ref,CurrPid,CaseNum,Mod,Func}|Ps] = Cases, Ok,Skip,Fail) ->
+ receive
+ {started,_,CurrPid,CaseNum,Mod,Func} ->
+ handle_io_and_exits(self(), CurrPid, CaseNum, Mod, Func, Cases),
+ Refs1 =
+ case Refs of
+ [Ref|Rs] -> % must be end conf case for subgroup
+ Rs;
+ _ when is_reference(Ref) -> % must be start of new subgroup
+ [Ref|Refs];
+ _ -> % must be normal subgroup testcase
+ Refs
+ end,
+ handle_io_and_exit_loop(Refs1, Ps, Ok,Skip,Fail)
+ after
+ 1000 ->
+ exit({testcase_failed_to_start,Mod,Func})
+ end;
+
+handle_io_and_exit_loop(_, [], Ok,Skip,Fail) ->
+ {lists:reverse(Ok),lists:reverse(Skip),lists:reverse(Fail)}.
+
+handle_io_and_exits(Main, CurrPid, CaseNum, Mod, Func, Cases) ->
+ receive
+ %% end of io session from test case executed by main process
+ {finished,_,Main,CaseNum,Mod,Func,Result,_RetVal} ->
+ {Result,{Mod,Func}};
+ %% end of io session from test case executed by parallel process
+ {finished,_,CurrPid,CaseNum,Mod,Func,Result,RetVal} ->
+ case Result of
+ ok ->
+ put(test_server_ok, get(test_server_ok)+1);
+ failed ->
+ put(test_server_failed, get(test_server_failed)+1);
+ skipped ->
+ SkipCounters =
+ update_skip_counters(RetVal, get(test_server_skipped)),
+ put(test_server_skipped, SkipCounters)
+ end,
+ {Result,{Mod,Func}};
+
+ %% print to common log file
+ {print,CurrPid,Detail,Msg} ->
+ output({Detail,Msg}, internal),
+ handle_io_and_exits(Main, CurrPid, CaseNum, Mod, Func, Cases);
+
+ %% unexpected termination of test case process
+ {'EXIT',TCPid,Reason} when Reason /= normal ->
+ {value,{_,_,Num,M,F}} = lists:keysearch(TCPid, 2, Cases),
+ print(1, "Error! Process for test case #~p (~p:~p) died! Reason: ~p",
+ [Num, M, F, Reason]),
+ exit({unexpected_termination,{Num,M,F},{TCPid,Reason}})
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% run_test_case(Ref, Num, Mod, Func, Args, RunInit,
+%% Where, MultiplyTimetrap, Mode) -> RetVal
+%%
+%% Creates the minor log file and inserts some test case specific headers
+%% and footers into the log files. If a remote target is used, the test
+%% suite (binary) and the content of data_dir is sent. Then the test case
+%% is executed and the result is printed to the log files (also info
+%% about lingering processes & slave nodes in the system is presented).
+%%
+%% RunInit decides if the per test case init is to be run (true for all
+%% but conf cases).
+%%
+%% Where specifies if the test case should run on target or on the host.
+%% (Note that 'make' test cases always run on host).
+%%
+%% Mode specifies if the test case should be executed by a dedicated,
+%% parallel, process rather than sequentially by the main process. If
+%% the former, the new process is spawned and the dictionary of the main
+%% process is copied to the test case process.
+%%
+%% RetVal is the result of executing the test case. It contains info
+%% about the execution time and the return value of the test case function.
+
+run_test_case(Ref, Num, Mod, Func, Args, RunInit, Where, MultiplyTimetrap) ->
+ file:set_cwd(filename:dirname(get(test_server_dir))),
+ run_test_case1(Ref, Num, Mod, Func, Args, RunInit, Where,
+ MultiplyTimetrap, [], [], self()).
+
+run_test_case(Ref, Num, Mod, Func, Args, skip_init, Where, MultiplyTimetrap, Mode) ->
+ %% a conf case is always executed by the main process
+ run_test_case1(Ref, Num, Mod, Func, Args, skip_init, Where,
+ MultiplyTimetrap, [], Mode, self());
+
+run_test_case(Ref, Num, Mod, Func, Args, RunInit, Where, MultiplyTimetrap, Mode) ->
+ file:set_cwd(filename:dirname(get(test_server_dir))),
+ case check_prop(parallel, Mode) of
+ false ->
+ %% this is a sequential test case
+ run_test_case1(Ref, Num, Mod, Func, Args, RunInit, Where,
+ MultiplyTimetrap, [], Mode, self());
+ _Ref ->
+ %% this a parallel test case, spawn the new process
+ Main = self(),
+ {dictionary,State} = process_info(self(), dictionary),
+ spawn_link(fun() ->
+ run_test_case1(Ref, Num, Mod, Func, Args, RunInit, Where,
+ MultiplyTimetrap, State, Mode, Main)
+ end)
+ end.
+
+run_test_case1(Ref, Num, Mod, Func, Args, RunInit, Where,
+ MultiplyTimetrap, State, Mode, Main) ->
+ %% if this runs on a parallel test case process,
+ %% copy the dictionary from the main process
+ do_if_parallel(Main, fun() -> process_flag(trap_exit, true) end, ok),
+ CopyDict = fun() -> lists:foreach(fun({Key,Val}) -> put(Key, Val) end, State) end,
+ do_if_parallel(Main, CopyDict, ok),
+ do_if_parallel(Main, fun() -> put(test_server_common_io_handler, {tc,Main}) end, ok),
+ %% if io is being buffered, send start io session message
+ %% (no matter if case runs on parallel or main process)
+ case get(test_server_common_io_handler) of
+ undefined -> ok;
+ _ -> Main ! {started,Ref,self(),Num,Mod,Func}
+ end,
+ TSDir = get(test_server_dir),
+ case Where of
+ target ->
+ maybe_send_beam_and_datadir(Mod);
+ host ->
+ ok
+ end,
+ test_server_sup:framework_call(report, [tc_start,{?pl2a(Mod),Func}]),
+ print(major, "=case ~p:~p", [Mod, Func]),
+ MinorName = start_minor_log_file(Mod, Func),
+ print(minor, "<a name=top></a>", []),
+ MinorBase = filename:basename(MinorName),
+ print(major, "=logfile ~s", [filename:basename(MinorName)]),
+ print_props((RunInit==skip_init), get_props(Mode)),
+ print(major, "=started ~s", [lists:flatten(timestamp_get(""))]),
+ {{Col0,Col1},Style} = get_font_style((RunInit==run_init), Mode),
+ print(html, "<tr valign=top><td>" ++ Col0 ++ "~s" ++ Col1 ++ "</td>"
+ "<td>" ++ Col0 ++ "~p" ++ Col1 ++ "</td>"
+ "<td><a href=\"~s\">~p</a></td>"
+ "<td><a href=\"~s#top\"><</a> <a href=\"~s#end\">></a></td>",
+ [num2str(Num),Mod,MinorBase,Func,MinorBase,MinorBase]),
+
+ do_if_parallel(Main, ok, fun erlang:yield/0),
+ %% run the test case
+ {Result,DetectedFail,ProcsBefore,ProcsAfter} =
+ run_test_case_apply(Num, Mod, Func, Args, get_name(Mode),
+ RunInit, Where, MultiplyTimetrap),
+ {Time,RetVal,Loc,Opts,Comment} =
+ case Result of
+ Normal={_Time,_RetVal,_Loc,_Opts,_Comment} -> Normal;
+ {died,DReason,DLoc,DCmt} -> {died,DReason,DLoc,[],DCmt}
+ end,
+
+ print(minor, "<a name=end></a>", []),
+ print_timestamp(minor, "Ended at "),
+ print(major, "=ended ~s", [lists:flatten(timestamp_get(""))]),
+
+ do_if_parallel(Main, ok, fun() -> file:set_cwd(filename:dirname(TSDir)) end),
+
+ %% call the appropriate progress function clause to print the results to log
+ Status =
+ case {Time,RetVal} of
+ {died,{timetrap_timeout,TimetrapTimeout}} ->
+ progress(failed, Num, Mod, Func, Loc,
+ timetrap_timeout, TimetrapTimeout, Comment, Style);
+ {died,Reason} ->
+ progress(failed, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {_,{'EXIT',{Skip,Reason}}} when Skip==skip; Skip==skipped ->
+ progress(skip, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {_,{'EXIT',_Pid,{Skip,Reason}}} when Skip==skip; Skip==skipped ->
+ progress(skip, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {_,{'EXIT',_Pid,Reason}} ->
+ progress(failed, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {_,{'EXIT',Reason}} ->
+ progress(failed, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {_, {failed, Reason}} ->
+ progress(failed, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {_, {Skip, Reason}} when Skip==skip; Skip==skipped ->
+ progress(skip, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style);
+ {Time,RetVal} ->
+ case DetectedFail of
+ [] ->
+ progress(ok, Num, Mod, Func, Loc, RetVal,
+ Time, Comment, Style);
+
+ Reason ->
+ progress(failed, Num, Mod, Func, Loc, Reason,
+ Time, Comment, Style)
+ end
+ end,
+ %% if the test case was executed sequentially, this updates the
+ %% status count on the main process (status of parallel test cases
+ %% is updated later by the handle_test_case_io_and_status/0 function)
+ case {RunInit,Status} of
+ {skip_init,_} -> % conf doesn't count
+ ok;
+ {_,ok} ->
+ put(test_server_ok, get(test_server_ok)+1);
+ {_,failed} ->
+ put(test_server_failed, get(test_server_failed)+1);
+ {_,skip} ->
+ {US,AS} = get(test_server_skipped),
+ put(test_server_skipped, {US+1,AS});
+ {_,auto_skip} ->
+ {US,AS} = get(test_server_skipped),
+ put(test_server_skipped, {US,AS+1})
+ end,
+ %% only if test case execution is sequential do we care about the
+ %% remaining processes and slave nodes count
+ case self() of
+ Main ->
+ case test_server_sup:framework_call(warn, [processes], true) of
+ true ->
+ if ProcsBefore < ProcsAfter ->
+ print(minor,
+ "WARNING: ~w more processes in system after test case",
+ [ProcsAfter-ProcsBefore]);
+ ProcsBefore > ProcsAfter ->
+ print(minor,
+ "WARNING: ~w less processes in system after test case",
+ [ProcsBefore-ProcsAfter]);
+ true -> ok
+ end;
+ false ->
+ ok
+ end,
+ case test_server_sup:framework_call(warn, [nodes], true) of
+ true ->
+ case catch controller_call(kill_slavenodes) of
+ {'EXIT',_}=Exit ->
+ print(minor,
+ "WARNING: There might be slavenodes left in the"
+ " system. I tried to kill them, but I failed: ~p\n",
+ [Exit]);
+ [] -> ok;
+ List ->
+ print(minor, "WARNING: ~w slave nodes in system after test"++
+ "case. Tried to killed them.~n"++
+ " Names:~p",
+ [length(List),List])
+ end;
+ false ->
+ ok
+ end;
+ _ ->
+ ok
+ end,
+ %% if the test case was executed sequentially, this updates the execution
+ %% time count on the main process (adding execution time of parallel test
+ %% case groups is done in run_test_cases_loop/4)
+ if is_number(Time) ->
+ put(test_server_total_time, get(test_server_total_time)+Time);
+ true ->
+ ok
+ end,
+ check_new_crash_dumps(Where),
+
+ %% if io is being buffered, send finished message
+ %% (no matter if case runs on parallel or main process)
+ case get(test_server_common_io_handler) of
+ undefined -> ok;
+ _ -> Main ! {finished,Ref,self(),Num,Mod,Func,
+ ?mod_result(Status),{Time,RetVal,Opts}}
+ end,
+ {Time,RetVal,Opts}.
+
+
+%%--------------------------------------------------------------------
+%% various help functions
+
+%% Call If() if we're on parallel process, or
+%% call Else() if we're on main process
+do_if_parallel(Pid, If, Else) ->
+ case self() of
+ Pid ->
+ if is_function(Else) -> Else();
+ true -> Else
+ end;
+ _ ->
+ if is_function(If) -> If();
+ true -> If
+ end
+ end.
+
+num2str(0) -> "";
+num2str(N) -> integer_to_list(N).
+
+%% If remote target, this function sends the test suite (if not already sent)
+%% and the content of datadir til target.
+maybe_send_beam_and_datadir(Mod) ->
+ case get(test_server_ctrl_job_sock) of
+ undefined ->
+ %% local target
+ ok;
+ JobSock ->
+ %% remote target
+ case get(test_server_downloaded_suites) of
+ undefined ->
+ send_beam_and_datadir(Mod, JobSock),
+ put(test_server_downloaded_suites, [Mod]);
+ Suites ->
+ case lists:member(Mod, Suites) of
+ false ->
+ send_beam_and_datadir(Mod, JobSock),
+ put(test_server_downloaded_suites, [Mod|Suites]);
+ true ->
+ ok
+ end
+ end
+ end.
+
+send_beam_and_datadir(Mod, JobSock) ->
+ case code:which(Mod) of
+ non_existing ->
+ io:format("** WARNING: Suite ~w could not be found on host\n",
+ [Mod]);
+ BeamFile ->
+ send_beam(JobSock, Mod, BeamFile)
+ end,
+ DataDir = get_data_dir(Mod),
+ case file:read_file_info(DataDir) of
+ {ok,_I} ->
+ {ok,All} = file:list_dir(DataDir),
+ AddTarFiles =
+ case controller_call(get_target_info) of
+ #target_info{os_family=ose} ->
+ ObjExt = code:objfile_extension(),
+ Wc = filename:join(DataDir, "*" ++ ObjExt),
+ ModsInDatadir = filelib:wildcard(Wc),
+ SendBeamFun = fun(X) -> send_beam(JobSock, X) end,
+ lists:foreach(SendBeamFun, ModsInDatadir),
+ %% No need to send C code or makefiles since
+ %% no compilation can be done on target anyway.
+ %% Compiled C code must exist on target.
+ %% Beam files are already sent as binaries.
+ %% Erlang source are sent in case the test case
+ %% is to compile it.
+ Filter = fun("Makefile") -> false;
+ ("Makefile.src") -> false;
+ (Y) ->
+ case filename:extension(Y) of
+ ".c" -> false;
+ ObjExt -> false;
+ _ -> true
+ end
+ end,
+ lists:filter(Filter, All);
+ _ ->
+ All
+ end,
+ Tarfile = "data_dir.tar.gz",
+ {ok,Tar} = erl_tar:open(Tarfile, [write,compressed]),
+ ShortDataDir = filename:basename(DataDir),
+ AddTarFun =
+ fun(File) ->
+ Long = filename:join(DataDir, File),
+ Short = filename:join(ShortDataDir, File),
+ ok = erl_tar:add(Tar, Long, Short, [])
+ end,
+ lists:foreach(AddTarFun, AddTarFiles),
+ ok = erl_tar:close(Tar),
+ {ok,TarBin} = file:read_file(Tarfile),
+ file:delete(Tarfile),
+ request(JobSock, {{datadir,Tarfile}, TarBin});
+ {error,_R} ->
+ ok
+ end.
+
+send_beam(JobSock, BeamFile) ->
+ Mod=filename:rootname(filename:basename(BeamFile), code:objfile_extension()),
+ send_beam(JobSock, list_to_atom(Mod), BeamFile).
+send_beam(JobSock, Mod, BeamFile) ->
+ {ok,BeamBin} = file:read_file(BeamFile),
+ request(JobSock, {{beam,Mod,BeamFile}, BeamBin}).
+
+check_new_crash_dumps(Where) ->
+ case Where of
+ target ->
+ case get(test_server_ctrl_job_sock) of
+ undefined ->
+ ok;
+ Socket ->
+ read_job_sock_loop(Socket)
+ end;
+ _ ->
+ ok
+ end,
+ test_server_sup:check_new_crash_dumps().
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% progress(Result, CaseNum, Mod, Func, Location, Reason, Time,
+%% Comment, TimeFormat) -> Result
+%%
+%% Prints the result of the test case to log file.
+%% Note: Strings that are to be written to the minor log must
+%% be prefixed with "=== " here, or the indentation will be wrong.
+
+progress(skip, CaseNum, Mod, Func, Loc, Reason, Time,
+ Comment, {St0,St1}) ->
+ {Reason1,{Color,Ret}} = if_auto_skip(Reason,
+ fun() -> {"#ffcc99",auto_skip} end,
+ fun() -> {"#ff9933",skip} end),
+ print(major, "=result skipped", []),
+ print(1, "*** SKIPPED *** ~s",
+ [get_info_str(Func, CaseNum, get(test_server_cases))]),
+ test_server_sup:framework_call(report, [tc_done,{?pl2a(Mod),Func,
+ {skipped,Reason1}}]),
+ ReasonStr = reason_to_string(Reason1),
+ ReasonStr1 = lists:flatten([string:strip(S,left) ||
+ S <- string:tokens(ReasonStr,[$\n])]),
+ ReasonStr2 =
+ if length(ReasonStr1) > 80 ->
+ string:substr(ReasonStr1, 1, 77) ++ "...";
+ true ->
+ ReasonStr1
+ end,
+ Comment1 = case Comment of
+ "" -> "";
+ _ -> "<br>(" ++ to_string(Comment) ++ ")"
+ end,
+ print(html,
+ "<td>" ++ St0 ++ "~.3fs" ++ St1 ++ "</td>"
+ "<td><font color=\"~s\">SKIPPED</font></td>"
+ "<td>~s~s</td></tr>\n",
+ [Time,Color,ReasonStr2,Comment1]),
+ FormatLoc = test_server_sup:format_loc(Loc),
+ print(minor, "=== location ~s", [FormatLoc]),
+ print(minor, "=== reason = ~s", [ReasonStr1]),
+ Ret;
+
+progress(failed, CaseNum, Mod, Func, Loc, timetrap_timeout, T,
+ Comment0, {St0,St1}) ->
+ print(major, "=result failed: timeout, ~p", [Loc]),
+ print(1, "*** FAILED *** ~s",
+ [get_info_str(Func, CaseNum, get(test_server_cases))]),
+ test_server_sup:framework_call(report,
+ [tc_done,{?pl2a(Mod),Func,
+ {failed,timetrap_timeout}}]),
+ FormatLastLoc = test_server_sup:format_loc(get_last_loc(Loc)),
+ ErrorReason = io_lib:format("{timetrap_timeout,~s}", [FormatLastLoc]),
+ Comment =
+ case Comment0 of
+ "" -> "<font color=\"red\">" ++ ErrorReason ++ "</font>";
+ _ -> "<font color=\"red\">" ++ ErrorReason ++ "</font><br>" ++
+ to_string(Comment0)
+ end,
+ print(html,
+ "<td>" ++ St0 ++ "~.3fs" ++ St1 ++ "</td>"
+ "<td><font color=\"red\">FAILED</font></td>"
+ "<td>~s</td></tr>\n",
+ [T/1000,Comment]),
+ FormatLoc = test_server_sup:format_loc(Loc),
+ print(minor, "=== location ~s", [FormatLoc]),
+ print(minor, "=== reason = timetrap timeout", []),
+ failed;
+
+progress(failed, CaseNum, Mod, Func, Loc, {testcase_aborted,Reason}, _T,
+ Comment0, {St0,St1}) ->
+ print(major, "=result failed: testcase_aborted, ~p", [Loc]),
+ print(1, "*** FAILED *** ~s",
+ [get_info_str(Func, CaseNum, get(test_server_cases))]),
+ test_server_sup:framework_call(report,
+ [tc_done,{?pl2a(Mod),Func,
+ {failed,testcase_aborted}}]),
+ FormatLastLoc = test_server_sup:format_loc(get_last_loc(Loc)),
+ ErrorReason = io_lib:format("{testcase_aborted,~s}", [FormatLastLoc]),
+ Comment =
+ case Comment0 of
+ "" -> "<font color=\"red\">" ++ ErrorReason ++ "</font>";
+ _ -> "<font color=\"red\">" ++ ErrorReason ++ "</font><br>" ++
+ to_string(Comment0)
+ end,
+ print(html,
+ "<td>" ++ St0 ++ "died" ++ St1 ++ "</td>"
+ "<td><font color=\"red\">FAILED</font></td>"
+ "<td>~s</td></tr>\n",
+ [Comment]),
+ FormatLoc = test_server_sup:format_loc(Loc),
+ print(minor, "=== location ~s", [FormatLoc]),
+ print(minor, "=== reason = {testcase_aborted,~p}", [Reason]),
+ failed;
+
+progress(failed, CaseNum, Mod, Func, unknown, Reason, Time,
+ Comment0, {St0,St1}) ->
+ print(major, "=result failed: ~p, ~p", [Reason,unknown]),
+ print(1, "*** FAILED *** ~s",
+ [get_info_str(Func, CaseNum, get(test_server_cases))]),
+ test_server_sup:framework_call(report, [tc_done,{?pl2a(Mod),Func,
+ {failed,Reason}}]),
+ TimeStr = io_lib:format(if is_float(Time) -> "~.3fs";
+ true -> "~w"
+ end, [Time]),
+ ErrorReason = lists:flatten(io_lib:format("~p", [Reason])),
+ ErrorReason1 = lists:flatten([string:strip(S,left) ||
+ S <- string:tokens(ErrorReason,[$\n])]),
+ ErrorReason2 =
+ if length(ErrorReason1) > 63 ->
+ string:substr(ErrorReason1, 1, 60) ++ "...";
+ true ->
+ ErrorReason1
+ end,
+ Comment =
+ case Comment0 of
+ "" -> "<font color=\"red\">" ++ ErrorReason2 ++ "</font>";
+ _ -> "<font color=\"red\">" ++ ErrorReason2 ++ "</font><br>" ++
+ to_string(Comment0)
+ end,
+ print(html,
+ "<td>" ++ St0 ++ "~s" ++ St1 ++ "</td>"
+ "<td><font color=\"red\">FAILED</font></td>"
+ "<td>~s</td></tr>\n",
+ [TimeStr,Comment]),
+ print(minor, "=== location ~s", [unknown]),
+ {FStr,FormattedReason} = format_exception(Reason),
+ print(minor, "=== reason = "++FStr, [FormattedReason]),
+ failed;
+
+progress(failed, CaseNum, Mod, Func, Loc, Reason, Time,
+ Comment0, {St0,St1}) ->
+ print(major, "=result failed: ~p, ~p", [Reason,Loc]),
+ print(1, "*** FAILED *** ~s",
+ [get_info_str(Func, CaseNum, get(test_server_cases))]),
+ test_server_sup:framework_call(report, [tc_done,{?pl2a(Mod),Func,
+ {failed,Reason}}]),
+ TimeStr = io_lib:format(if is_float(Time) -> "~.3fs";
+ true -> "~w"
+ end, [Time]),
+ Comment =
+ case Comment0 of
+ "" -> "";
+ _ -> "<br>" ++ to_string(Comment0)
+ end,
+ FormatLastLoc = test_server_sup:format_loc(get_last_loc(Loc)),
+ print(html,
+ "<td>" ++ St0 ++ "~s" ++ St1 ++ "</td>"
+ "<td><font color=\"red\">FAILED</font></td>"
+ "<td><font color=\"red\">~s</font>~s</td></tr>\n",
+ [TimeStr,FormatLastLoc,Comment]),
+ FormatLoc = test_server_sup:format_loc(Loc),
+ print(minor, "=== location ~s", [FormatLoc]),
+ {FStr,FormattedReason} = format_exception(Reason),
+ print(minor, "=== reason = "++FStr, [FormattedReason]),
+ failed;
+
+progress(ok, _CaseNum, Mod, Func, _Loc, RetVal, Time,
+ Comment0, {St0,St1}) ->
+ print(minor, "successfully completed test case", []),
+ test_server_sup:framework_call(report, [tc_done,{?pl2a(Mod),Func,ok}]),
+ Comment =
+ case RetVal of
+ {comment,RetComment} ->
+ String = to_string(RetComment),
+ print(major, "=result ok: ~s", [String]),
+ "<td>" ++ String ++ "</td>";
+ _ ->
+ print(major, "=result ok", []),
+ case Comment0 of
+ "" -> "";
+ _ -> "<td>" ++ to_string(Comment0) ++ "</td>"
+ end
+ end,
+ print(major, "=elapsed ~p", [Time]),
+ print(html,
+ "<td>" ++ St0 ++ "~.3fs" ++ St1 ++ "</td>"
+ "<td><font color=\"green\">Ok</font></td>"
+ "~s</tr>\n",
+ [Time,Comment]),
+ print(minor, "=== returned value = ~p", [RetVal]),
+ ok.
+
+%%--------------------------------------------------------------------
+%% various help functions
+
+if_auto_skip(Reason={failed,{_,init_per_testcase,_}}, True, _False) ->
+ {Reason,True()};
+if_auto_skip({_T,{skip,Reason={failed,{_,init_per_testcase,_}}},_Opts}, True, _False) ->
+ {Reason,True()};
+if_auto_skip({fw_auto_skip,Reason}, True, _False) ->
+ {Reason,True()};
+if_auto_skip({_T,{skip,{fw_auto_skip,Reason}},_Opts}, True, _False) ->
+ {Reason,True()};
+if_auto_skip(Reason, _True, False) ->
+ {Reason,False()}.
+
+update_skip_counters(RetVal, {US,AS}) ->
+ {_,Result} = if_auto_skip(RetVal, fun() -> {US,AS+1} end, fun() -> {US+1,AS} end),
+ Result.
+
+get_info_str(Func, 0, _Cases) ->
+ atom_to_list(Func);
+get_info_str(_Func, CaseNum, unknown) ->
+ "test case " ++ integer_to_list(CaseNum);
+get_info_str(_Func, CaseNum, Cases) ->
+ "test case " ++ integer_to_list(CaseNum) ++
+ " of " ++ integer_to_list(Cases).
+
+print_if_known(Known, {SK,AK}, {SU,AU}) ->
+ {S,A} = if Known == unknown -> {SU,AU};
+ true -> {SK,AK}
+ end,
+ io_lib:format(S, A).
+
+to_string(Term) when is_list(Term) ->
+ case (catch io_lib:format("~s", [Term])) of
+ {'EXIT',_} -> io_lib:format("~p", [Term]);
+ String -> lists:flatten(String)
+ end;
+to_string(Term) ->
+ lists:flatten(io_lib:format("~p", [Term])).
+
+get_last_loc(Loc) when is_tuple(Loc) ->
+ Loc;
+get_last_loc([Loc|_]) when is_tuple(Loc) ->
+ [Loc];
+get_last_loc(Loc) ->
+ Loc.
+
+reason_to_string({failed,{_,FailFunc,bad_return}}) ->
+ atom_to_list(FailFunc) ++ " bad return value";
+reason_to_string({failed,{_,FailFunc,{timetrap_timeout,_}}}) ->
+ atom_to_list(FailFunc) ++ " timed out";
+reason_to_string(FWInitFail = {failed,{_CB,init_tc,_Reason}}) ->
+ to_string(FWInitFail);
+reason_to_string({failed,{_,FailFunc,_}}) ->
+ atom_to_list(FailFunc) ++ " failed";
+reason_to_string(Other) ->
+ to_string(Other).
+
+%get_font_style(Prop) ->
+% {Col,St0,St1} = get_font_style1(Prop),
+% {{"<font color="++Col++">","</font>"},
+% {"<font color="++Col++">"++St0,St1++"</font>"}}.
+
+get_font_style(NormalCase, Mode) ->
+ Prop = if not NormalCase ->
+ default;
+ true ->
+ case check_prop(parallel, Mode) of
+ false ->
+ case check_prop(sequence, Mode) of
+ false ->
+ default;
+ _ ->
+ sequence
+ end;
+ _ ->
+ parallel
+ end
+ end,
+ {Col,St0,St1} = get_font_style1(Prop),
+ {{"<font color="++Col++">","</font>"},
+ {"<font color="++Col++">"++St0,St1++"</font>"}}.
+
+get_font_style1(parallel) ->
+ {"\"darkslategray\"","<i>","</i>"};
+get_font_style1(sequence) ->
+% {"\"darkolivegreen\"","",""};
+ {"\"saddlebrown\"","",""};
+get_font_style1(default) ->
+ {"\"black\"","",""}.
+%%get_font_style1(skipped) ->
+%% {"\"lightgray\"","",""}.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% format_exception({Error,Stack}) -> {CtrlSeq,Term}
+%%
+%% The default behaviour is that error information gets formatted
+%% (like in the erlang shell) before printed to the minor log file.
+%% The framework application can switch this feature off by setting
+%% *its* application environment variable 'format_exception' to false.
+%% It is also possible to switch formatting off by starting the
+%% test_server node with init argument 'test_server_format_exception'
+%% set to false.
+
+format_exception(Reason={_Error,Stack}) when is_list(Stack) ->
+ case os:getenv("TEST_SERVER_FRAMEWORK") of
+ false ->
+ case application:get_env(test_server, format_exception) of
+ {ok,false} ->
+ {"~p",Reason};
+ _ ->
+ do_format_exception(Reason)
+ end;
+ FW ->
+ case application:get_env(list_to_atom(FW), format_exception) of
+ {ok,false} ->
+ {"~p",Reason};
+ _ ->
+ do_format_exception(Reason)
+ end
+ end;
+format_exception(Error) ->
+ format_exception({Error,[]}).
+
+do_format_exception(Reason={Error,Stack}) ->
+ StackFun = fun(_, _, _) -> false end,
+ PF = fun(Term, I) ->
+ io_lib:format("~." ++ integer_to_list(I) ++ "p", [Term])
+ end,
+ case catch lib:format_exception(1, error, Error, Stack, StackFun, PF) of
+ {'EXIT',_} ->
+ {"~p",Reason};
+ Formatted ->
+ Formatted1 = re:replace(Formatted, "exception error: ", "", [{return,list}]),
+ {"~s",lists:flatten(Formatted1)}
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% run_test_case_apply(CaseNum, Mod, Func, Args, Name, RunInit,
+%% Where, MultiplyTimetrap) ->
+%% {{Time,RetVal,Loc,Opts,Comment},DetectedFail,ProcessesBefore,ProcessesAfter} |
+%% {{died,Reason,unknown,Comment},DetectedFail,ProcessesBefore,ProcessesAfter}
+%% Name = atom()
+%% Where = target | host
+%% Time = float() (seconds)
+%% RetVal = term()
+%% Loc = term()
+%% Comment = string()
+%% Reason = term()
+%% DetectedFail = [{File,Line}]
+%% ProcessesBefore = ProcessesAfter = integer()
+%%
+%% Where indicates if the test should run on target or always on the host.
+%%
+%% If test is to be run on target, and target is remote the request is
+%% sent over socket to target, and test_server runs the case and sends the
+%% result back over the socket. Else test_server runs the case directly on host.
+
+run_test_case_apply(CaseNum, Mod, Func, Args, Name, RunInit, host, MultiplyTimetrap) ->
+ test_server:run_test_case_apply({CaseNum,Mod,Func,Args,Name,RunInit,
+ MultiplyTimetrap});
+run_test_case_apply(CaseNum, Mod, Func, Args, Name, RunInit, target, MultiplyTimetrap) ->
+ case get(test_server_ctrl_job_sock) of
+ undefined ->
+ %% local target
+ test_server:run_test_case_apply({CaseNum,Mod,Func,Args,Name,RunInit,
+ MultiplyTimetrap});
+ JobSock ->
+ %% remote target
+ request(JobSock, {test_case,{CaseNum,Mod,Func,Args,Name,RunInit,
+ MultiplyTimetrap}}),
+ read_job_sock_loop(JobSock)
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% print(Detail, Format, Args) -> ok
+%% Detail = integer()
+%% Format = string()
+%% Args = [term()]
+%%
+%% Just like io:format, except that depending on the Detail value, the output
+%% is directed to console, major and/or minor log files.
+%%
+%% To handle printouts to common (not minor) log files from parallel test
+%% case processes, the test_server_common_io_handler value is checked. If
+%% set, the data is sent to the main controlling process. Note that test
+%% cases that belong to a conf group nested under a parallel group will also
+%% get its io data sent to main rather than immediately printed out, even
+%% if the test cases are executed by the same, main, process (ie the main
+%% process sends messages to itself then).
+%%
+%% Buffered io is handled by the handle_test_case_io_and_status/0 function.
+
+print(Detail, Format) ->
+ print(Detail, Format, []).
+
+print(Detail, Format, Args) ->
+ print(Detail, Format, Args, internal).
+
+print(Detail, Format, Args, Printer) ->
+ Msg = io_lib:format(Format, Args),
+ print_or_buffer(Detail, Msg, Printer).
+
+print_or_buffer(Detail, Msg, Printer) ->
+ case get(test_server_minor_level) of
+ _ when Detail == minor ->
+ output({Detail,Msg}, Printer);
+ MinLevel when is_number(Detail), Detail >= MinLevel ->
+ output({Detail,Msg}, Printer);
+ _ -> % Detail < Minor | major | html
+ case get(test_server_common_io_handler) of
+ undefined ->
+ output({Detail,Msg}, Printer);
+ {_,MainPid} ->
+ MainPid ! {print,self(),Detail,Msg}
+ end
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% print_timestamp(Detail, Leader) -> ok
+%%
+%% Prints Leader followed by a time stamp (date and time). Depending on
+%% the Detail value, the output is directed to console, major and/or minor
+%% log files.
+
+print_timestamp(Detail, Leader) ->
+ print(Detail, timestamp_get(Leader), []).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% print_who(Host, User) -> ok
+%%
+%% Logs who runs the suite.
+
+print_who(Host, User) ->
+ UserStr = case User of
+ "" -> "";
+ _ -> " by " ++ User
+ end,
+ print(html, "Run~s on ~s", [UserStr,Host]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% format(Format) -> IoLibReturn
+%% format(Detail, Format) -> IoLibReturn
+%% format(Format, Args) -> IoLibReturn
+%% format(Detail, Format, Args) -> IoLibReturn
+%%
+%% Detail = integer()
+%% Format = string()
+%% Args = [term(),...]
+%% IoLibReturn = term()
+%%
+%% Logs the Format string and Args, similar to io:format/1/2 etc. If
+%% Detail is not specified, the default detail level (which is 50) is used.
+%% Which log files the string will be logged in depends on the thresholds
+%% set with set_levels/3. Typically with default detail level, only the
+%% minor log file is used.
+
+format(Format) ->
+ format(minor, Format, []).
+
+format(major, Format) ->
+ format(major, Format, []);
+format(minor, Format) ->
+ format(minor, Format, []);
+format(Detail, Format) when is_integer(Detail) ->
+ format(Detail, Format, []);
+format(Format, Args) ->
+ format(minor, Format, Args).
+
+format(Detail, Format, Args) ->
+ Str =
+ case catch io_lib:format(Format, Args) of
+ {'EXIT',_} ->
+ io_lib:format("illegal format; ~p with args ~p.\n",
+ [Format,Args]);
+ Valid -> Valid
+ end,
+ print_or_buffer(Detail, Str, self()).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% output({Level,Message}, Sender) -> ok
+%% Level = integer() | minor | major | html
+%% Message = string() | [integer()]
+%% Sender = string() | internal
+%%
+%% Outputs the message on the channels indicated by Level. If Level is an
+%% atom, only the corresponding channel receives the output. When Level is
+%% an integer console, major and/or minor log file will receive output
+%% depending on the user set thresholds (see get_levels/0, set_levels/3)
+%%
+%% When printing on the console, the message is prefixed with the test
+%% suite's name. In case a name is not set (yet), Sender is used.
+%%
+%% When not outputting to the console, and the Sender is 'internal',
+%% the message is prefixed with "=== ", so that it will be apparent that
+%% the message comes from the test server and not the test suite itself.
+
+output({Level,Msg}, Sender) when is_integer(Level) ->
+ SumLev = get(test_server_summary_level),
+ if Level =< SumLev ->
+ output_to_fd(stdout, Msg, Sender);
+ true ->
+ ok
+ end,
+ MajLev = get(test_server_major_level),
+ if Level =< MajLev ->
+ output_to_fd(get(test_server_major_fd), Msg, Sender);
+ true ->
+ ok
+ end,
+ MinLev = get(test_server_minor_level),
+ if Level >= MinLev ->
+ output_to_fd(get(test_server_minor_fd), Msg, Sender);
+ true ->
+ ok
+ end;
+output({minor,Bytes}, Sender) when is_list(Bytes) ->
+ output_to_fd(get(test_server_minor_fd), Bytes, Sender);
+output({major,Bytes}, Sender) when is_list(Bytes) ->
+ output_to_fd(get(test_server_major_fd), Bytes, Sender);
+output({minor,Bytes}, Sender) when is_binary(Bytes) ->
+ output_to_fd(get(test_server_minor_fd),binary_to_list(Bytes), Sender);
+output({major,Bytes}, Sender) when is_binary(Bytes) ->
+ output_to_fd(get(test_server_major_fd),binary_to_list(Bytes), Sender);
+output({html,Msg}, _Sender) ->
+ case get(test_server_html_fd) of
+ undefined ->
+ ok;
+ Fd ->
+ io:put_chars(Fd,Msg),
+ case file:position(Fd, {cur, 0}) of
+ {ok, Pos} ->
+ %% We are writing to a seekable file. Finalise so
+ %% we get complete valid (and viewable) HTML code.
+ %% Then rewind to overwrite the finalising code.
+ io:put_chars(Fd, "\n</table>\n</body>\n</html>\n"),
+ file:position(Fd, Pos);
+ {error, epipe} ->
+ %% The file is not seekable. We cannot erase what
+ %% we've already written --- so the reader will
+ %% have to wait until we're done.
+ ok
+ end
+ end;
+output({minor,Data}, Sender) ->
+ output_to_fd(get(test_server_minor_fd),
+ lists:flatten(io_lib:format(
+ "Unexpected output: ~p~n", [Data])),Sender);
+output({major,Data}, Sender) ->
+ output_to_fd(get(test_server_major_fd),
+ lists:flatten(io_lib:format(
+ "Unexpected output: ~p~n", [Data])),Sender).
+
+output_to_fd(stdout, Msg, Sender) ->
+ Name =
+ case get(test_server_name) of
+ undefined -> Sender;
+ Other -> Other
+ end,
+ io:format("Testing ~s: ~s\n", [Name, lists:flatten(Msg)]);
+output_to_fd(undefined, _Msg, _Sender) ->
+ ok;
+output_to_fd(Fd, [$=|Msg], internal) ->
+ io:put_chars(Fd, [$=]),
+ io:put_chars(Fd, Msg),
+ io:put_chars(Fd, "\n");
+output_to_fd(Fd, Msg, internal) ->
+ io:put_chars(Fd, [$=,$=,$=,$ ]),
+ io:put_chars(Fd, Msg),
+ io:put_chars(Fd, "\n");
+output_to_fd(Fd, Msg, _Sender) ->
+ io:put_chars(Fd, Msg),
+ io:put_chars(Fd, "\n").
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timestamp_filename_get(Leader) -> string()
+%% Leader = string()
+%%
+%% Returns a string consisting of Leader concatenated with the current
+%% date and time. The resulting string is suitable as a filename.
+timestamp_filename_get(Leader) ->
+ timestamp_get_internal(Leader,
+ "~s~w-~2.2.0w-~2.2.0w_~2.2.0w.~2.2.0w.~2.2.0w").
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timestamp_get(Leader) -> string()
+%% Leader = string()
+%%
+%% Returns a string consisting of Leader concatenated with the current
+%% date and time. The resulting string is suitable for display.
+timestamp_get(Leader) ->
+ timestamp_get_internal(Leader,
+ "~s~w-~2.2.0w-~2.2.0w ~2.2.0w:~2.2.0w:~2.2.0w").
+
+timestamp_get_internal(Leader, Format) ->
+ {YY,MM,DD,H,M,S} = time_get(),
+ io_lib:format(Format, [Leader,YY,MM,DD,H,M,S]).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% time_get() -> {YY,MM,DD,H,M,S}
+%% YY = integer()
+%% MM = integer()
+%% DD = integer()
+%% H = integer()
+%% M = integer()
+%% S = integer()
+%%
+%% Returns the current Year,Month,Day,Hours,Minutes,Seconds.
+%% The function checks that the date doesn't wrap while calling
+%% getting the time.
+time_get() ->
+ {YY,MM,DD} = date(),
+ {H,M,S} = time(),
+ case date() of
+ {YY,MM,DD} ->
+ {YY,MM,DD,H,M,S};
+ _NewDay ->
+ %% date changed between call to date() and time(), try again
+ time_get()
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% make_config(Config) -> NewConfig
+%% Config = [{Key,Value},...]
+%% NewConfig = [{Key,Value},...]
+%%
+%% Creates a configuration list (currently returns it's input)
+
+make_config(Initial) ->
+ Initial.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% update_config(Config, Update) -> NewConfig
+%% Config = [{Key,Value},...]
+%% Update = [{Key,Value},...] | {Key,Value}
+%% NewConfig = [{Key,Value},...]
+%%
+%% Adds or replaces the key-value pairs in config with those in update.
+%% Returns the updated list.
+
+update_config(Config, {Key,Val}) ->
+ case lists:keymember(Key, 1, Config) of
+ true ->
+ lists:keyreplace(Key, 1, Config, {Key,Val});
+ false ->
+ [{Key,Val}|Config]
+ end;
+update_config(Config, [Assoc|Assocs]) ->
+ NewConfig = update_config(Config, Assoc),
+ update_config(NewConfig, Assocs);
+update_config(Config, []) ->
+ Config.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% collect_cases(CurMod, TopCase, SkipList) ->
+%% BasicCaseList | {error,Reason}
+%%
+%% CurMod = atom()
+%% TopCase = term()
+%% SkipList = [term(),...]
+%% BasicCaseList = [term(),...]
+%%
+%% Parses the given test goal(s) in TopCase, and transforms them to a
+%% simple list of test cases to call, when executing the test suite.
+%%
+%% CurMod is the "current" module, that is, the module the last instruction
+%% was read from. May be be set to 'none' initially.
+%%
+%% SkipList is the list of test cases to skip and requirements to deny.
+%%
+%% The BasicCaseList is built out of TopCase, which may be any of the
+%% following terms:
+%%
+%% [] Nothing is added
+%% List list() The list is decomposed, and each element is
+%% treated according to this table
+%% Case atom() CurMod:Case(suite) is called
+%% {module,Case} CurMod:Case(suite) is called
+%% {Module,Case} Module:Case(suite) is called
+%% {module,Module,Case} Module:Case(suite) is called
+%% {module,Module,Case,Args} Module:Case is called with Args as arguments
+%% {dir,Dir} All modules *_SUITE in the named directory
+%% are listed, and each Module:all(suite) is called
+%% {dir,Dir,Pattern} All modules <Pattern>_SUITE in the named dir
+%% are listed, and each Module:all(suite) is called
+%% {conf,InitMF,Cases,FinMF}
+%% {conf,Props,InitMF,Cases,FinMF}
+%% InitMF is placed in the BasicCaseList, then
+%% Cases is treated according to this table, then
+%% FinMF is placed in the BasicCaseList. InitMF
+%% and FinMF are configuration manipulation
+%% functions. See below.
+%% {make,InitMFA,Cases,FinMFA}
+%% InitMFA is placed in the BasicCaseList, then
+%% Cases is treated according to this table, then
+%% FinMFA is placed in the BasicCaseList. InitMFA
+%% and FinMFA are make/unmake functions. If InitMFA
+%% fails, Cases are not run. InitMFA and FinMFA are
+%% always run on the host - not on target.
+%%
+%% When a function is called, above, it means that the function is invoked
+%% and the return is expected to be:
+%%
+%% [] Leaf case
+%% {req,ReqList} Kept for backwards compatibility - same as []
+%% {req,ReqList,Cases} Kept for backwards compatibility -
+%% Cases parsed recursively with collect_cases/3
+%% Cases (list) Recursively parsed with collect_cases/3
+%%
+%% Leaf cases are added to the BasicCaseList as Module:Case(Config). Each
+%% case is checked against the SkipList. If present, a skip instruction
+%% is inserted instead, which only prints the case name and the reason
+%% why the case was skipped in the log files.
+%%
+%% Configuration manipulation functions are called with the current
+%% configuration list as only argument, and are expected to return a new
+%% configuration list. Such a pair of function may, for example, start a
+%% server and stop it after a serie of test cases.
+%%
+%% SkipCases is expected to be in the format:
+%%
+%% Other Recursively parsed with collect_cases/3
+%% {Mod,Comment} Skip Mod, with Comment
+%% {Mod,Funcs,Comment} Skip listed functions in Mod with Comment
+%% {Mod,Func,Comment} Skip named function in Mod with Comment
+%%
+-record(cc, {mod, % current module
+ skip}). % skip list
+
+collect_all_cases(Top, Skip) when is_list(Skip) ->
+ Result =
+ case collect_cases(Top, #cc{mod=[],skip=Skip}) of
+ {ok,Cases,_St} -> Cases;
+ Other -> Other
+ end,
+ Result.
+
+
+collect_cases([], St) -> {ok,[],St};
+collect_cases([Case|Cs0], St0) ->
+ case collect_cases(Case, St0) of
+ {ok,FlatCases1,St1} ->
+ case collect_cases(Cs0, St1) of
+ {ok,FlatCases2,St} ->
+ {ok,FlatCases1 ++ FlatCases2,St};
+ {error,_Reason}=Error -> Error
+ end;
+ {error,_Reason}=Error -> Error
+ end;
+
+
+collect_cases({module,Case}, St) when is_atom(Case), is_atom(St#cc.mod) ->
+ collect_case({St#cc.mod,Case}, St);
+collect_cases({module,Mod,Case}, St) ->
+ collect_case({Mod,Case}, St);
+collect_cases({module,Mod,Case,Args}, St) ->
+ collect_case({Mod,Case,Args}, St);
+
+collect_cases({dir,SubDir}, St) ->
+ collect_files(SubDir, "*_SUITE", St);
+collect_cases({dir,SubDir,Pattern}, St) ->
+ collect_files(SubDir, Pattern++"*", St);
+
+collect_cases({conf,InitF,CaseList,FinMF}, St) when is_atom(InitF) ->
+ collect_cases({conf,[],{St#cc.mod,InitF},CaseList,FinMF}, St);
+collect_cases({conf,InitMF,CaseList,FinF}, St) when is_atom(FinF) ->
+ collect_cases({conf,[],InitMF,CaseList,{St#cc.mod,FinF}}, St);
+collect_cases({conf,InitMF,CaseList,FinMF}, St0) ->
+ collect_cases({conf,[],InitMF,CaseList,FinMF}, St0);
+collect_cases({conf,Props,InitF,CaseList,FinMF}, St) when is_atom(InitF) ->
+ collect_cases({conf,Props,{St#cc.mod,InitF},CaseList,FinMF}, St);
+collect_cases({conf,Props,InitMF,CaseList,FinF}, St) when is_atom(FinF) ->
+ collect_cases({conf,Props,InitMF,CaseList,{St#cc.mod,FinF}}, St);
+collect_cases({conf,Props,InitMF,CaseList,FinMF}, St0) ->
+ case collect_cases(CaseList, St0) of
+ {ok,[],_St}=Empty ->
+ Empty;
+ {ok,FlatCases,St} ->
+ Ref = make_ref(),
+ case in_skip_list(InitMF, St#cc.skip) of
+ {true,Comment} ->
+ {ok,[{skip_case,{conf,Ref,InitMF,Comment}} |
+ FlatCases ++ [{conf,Ref,[],FinMF}]],St};
+ false ->
+ {ok,[{conf,Ref,Props,InitMF} |
+ FlatCases ++ [{conf,Ref,keep_name(Props),FinMF}]],St}
+ end;
+ {error,_Reason}=Error ->
+ Error
+ end;
+
+collect_cases({make,InitMFA,CaseList,FinMFA}, St0) ->
+ case collect_cases(CaseList, St0) of
+ {ok,[],_St}=Empty -> Empty;
+ {ok,FlatCases,St} ->
+ Ref = make_ref(),
+ {ok,[{make,Ref,InitMFA}|FlatCases ++
+ [{make,Ref,FinMFA}]],St};
+ {error,_Reason}=Error -> Error
+ end;
+
+collect_cases({Module, Cases}, St) when is_list(Cases) ->
+ case (catch collect_case(Cases, St#cc{mod=Module}, [])) of
+ {ok, NewCases, NewSt} ->
+ {ok, NewCases, NewSt};
+ Other ->
+ {error, Other}
+ end;
+
+collect_cases({_Mod,_Case}=Spec, St) ->
+ collect_case(Spec, St);
+
+collect_cases({_Mod,_Case,_Args}=Spec, St) ->
+ collect_case(Spec, St);
+collect_cases(Case, St) when is_atom(Case), is_atom(St#cc.mod) ->
+ collect_case({St#cc.mod,Case}, St);
+collect_cases(Other, _St) ->
+ {error,{bad_subtest_spec,Other}}.
+
+collect_case(MFA, St) ->
+ case in_skip_list(MFA, St#cc.skip) of
+ {true,Comment} ->
+ {ok,[{skip_case,{MFA,Comment}}],St};
+ false ->
+ case MFA of
+ {Mod,Case} -> collect_case_invoke(Mod, Case, MFA, St);
+ {_Mod,_Case,_Args} -> {ok,[MFA],St}
+ end
+ end.
+
+collect_case([], St, Acc) ->
+ {ok, Acc, St};
+
+collect_case([Case | Cases], St, Acc) ->
+ {ok, FlatCases, NewSt} = collect_case({St#cc.mod, Case}, St),
+ collect_case(Cases, NewSt, Acc ++ FlatCases).
+
+collect_case_invoke(Mod, Case, MFA, St) ->
+ case os:getenv("TEST_SERVER_FRAMEWORK") of
+ false ->
+ case catch apply(Mod, Case, [suite]) of
+ {'EXIT',_} ->
+ {ok,[MFA],St};
+ Suite ->
+ collect_subcases(Mod, Case, MFA, St, Suite)
+ end;
+ _ ->
+ Suite = test_server_sup:framework_call(get_suite, [?pl2a(Mod),Case],[]),
+ collect_subcases(Mod, Case, MFA, St, Suite)
+ end.
+
+collect_subcases(Mod, Case, MFA, St, Suite) ->
+ case Suite of
+ [] when Case == all -> {ok,[],St};
+ [] -> {ok,[MFA],St};
+%%%! --- START Kept for backwards compatibilty ---
+%%%! Requirements are not used
+ {req,ReqList} ->
+ collect_case_deny(Mod, Case, MFA, ReqList, [], St);
+ {req,ReqList,SubCases} ->
+ collect_case_deny(Mod, Case, MFA, ReqList, SubCases, St);
+%%%! --- END Kept for backwards compatibilty ---
+ {Skip,Reason} when Skip==skip; Skip==skipped ->
+ {ok,[{skip_case,{MFA,Reason}}],St};
+ SubCases ->
+ collect_case_subcases(Mod, Case, SubCases, St)
+ end.
+
+collect_case_subcases(Mod, Case, SubCases, St0) ->
+ OldMod = St0#cc.mod,
+ case collect_cases(SubCases, St0#cc{mod=Mod}) of
+ {ok,FlatCases,St} ->
+ {ok,FlatCases,St#cc{mod=OldMod}};
+ {error,Reason} ->
+ {error,{{Mod,Case},Reason}}
+ end.
+
+collect_files(Dir, Pattern, St) ->
+ {ok,Cwd} = file:get_cwd(),
+ Dir1 = filename:join(Cwd, Dir),
+ Wc = filename:join([Dir1,Pattern++code:objfile_extension()]),
+ case catch filelib:wildcard(Wc) of
+ {'EXIT', Reason} ->
+ io:format("Could not collect files: ~p~n", [Reason]),
+ {error,{collect_fail,Dir,Pattern}};
+ Mods0 ->
+ Mods = [{path_to_module(Mod),all} || Mod <- lists:sort(Mods0)],
+ collect_cases(Mods, St)
+ end.
+
+path_to_module(Path) ->
+ list_to_atom(filename:rootname(filename:basename(Path))).
+
+collect_case_deny(Mod, Case, MFA, ReqList, SubCases, St) ->
+ case {check_deny(ReqList, St#cc.skip),SubCases} of
+ {{denied,Comment},_SubCases} ->
+ {ok,[{skip_case,{MFA,Comment}}],St};
+ {granted,[]} ->
+ {ok,[MFA],St};
+ {granted,SubCases} ->
+ collect_case_subcases(Mod, Case, SubCases, St)
+ end.
+
+check_deny([Req|Reqs], DenyList) ->
+ case check_deny_req(Req, DenyList) of
+ {denied,_Comment}=Denied -> Denied;
+ granted -> check_deny(Reqs, DenyList)
+ end;
+check_deny([], _DenyList) -> granted;
+check_deny(Req, DenyList) -> check_deny([Req], DenyList).
+
+check_deny_req({Req,Val}, DenyList) ->
+ %%io:format("ValCheck ~p=~p in ~p\n", [Req,Val,DenyList]),
+ case lists:keysearch(Req, 1, DenyList) of
+ {value,{_Req,DenyVal}} when Val >= DenyVal ->
+ {denied,io_lib:format("Requirement ~p=~p", [Req,Val])};
+ _ ->
+ check_deny_req(Req, DenyList)
+ end;
+check_deny_req(Req, DenyList) ->
+ case lists:member(Req, DenyList) of
+ true -> {denied,io_lib:format("Requirement ~p", [Req])};
+ false -> granted
+ end.
+
+in_skip_list({Mod,Func,_Args}, SkipList) ->
+ in_skip_list({Mod,Func}, SkipList);
+in_skip_list({Mod,Func}, [{Mod,Funcs,Comment}|SkipList]) when is_list(Funcs) ->
+ case lists:member(Func, Funcs) of
+ true ->
+ {true,Comment};
+ _ ->
+ in_skip_list({Mod,Func}, SkipList)
+ end;
+in_skip_list({Mod,Func}, [{Mod,Func,Comment}|_SkipList]) ->
+ {true,Comment};
+in_skip_list({Mod,_Func}, [{Mod,Comment}|_SkipList]) ->
+ {true,Comment};
+in_skip_list({Mod,Func}, [_|SkipList]) ->
+ in_skip_list({Mod,Func}, SkipList);
+in_skip_list(_, []) ->
+ false.
+
+keep_name(Props) ->
+ lists:filter(fun({name,_}) -> true; (_) -> false end, Props).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Target node handling functions %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% get_target_info() -> #target_info
+%%
+%% Returns a record containing system information for target
+
+get_target_info() ->
+ controller_call(get_target_info).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% start_node(SlaveName, Type, Options) ->
+%% {ok, Slave} | {error, Reason}
+%%
+%% Called by test_server. See test_server:start_node/3 for details
+
+start_node(Name, Type, Options) ->
+ T = 10 * ?ACCEPT_TIMEOUT, % give some extra time
+ format(minor, "Attempt to start ~w node ~p with options ~p",
+ [Type, Name, Options]),
+ case controller_call({start_node,Name,Type,Options}, T) of
+ {{ok,Nodename}, Host, Cmd, Info, Warning} ->
+ format(minor,
+ "Successfully started node ~p on ~p with command: ~p",
+ [Nodename, Host, Cmd]),
+ format(major, "=node_start ~p", [Nodename]),
+ case Info of
+ [] -> ok;
+ _ -> format(minor, Info)
+ end,
+ case Warning of
+ [] -> ok;
+ _ ->
+ format(1, Warning),
+ format(minor, Warning)
+ end,
+ {ok, Nodename};
+ {fail,{Ret, Host, Cmd}} ->
+ format(minor,
+ "Failed to start node ~p on ~p with command: ~p~n"
+ "Reason: ~p",
+ [Name, Host, Cmd, Ret]),
+ {fail,Ret};
+ {Ret, undefined, undefined} ->
+ format(minor, "Failed to start node ~p: ~p", [Name,Ret]),
+ Ret;
+ {Ret, Host, Cmd} ->
+ format(minor,
+ "Failed to start node ~p on ~p with command: ~p~n"
+ "Reason: ~p",
+ [Name, Host, Cmd, Ret]),
+ Ret
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% wait_for_node(Node) -> ok | {error,timeout}
+%%
+%% Wait for a slave/peer node which has been started with
+%% the option {wait,false}. This function returns when
+%% when the new node has contacted test_server_ctrl again
+
+wait_for_node(Slave) ->
+ case catch controller_call({wait_for_node,Slave},10000) of
+ {'EXIT',{timeout,_}} -> {error,timeout};
+ ok -> ok
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% is_release_available(Release) -> true | false
+%% Release -> string()
+%%
+%% Test if a release (such as "r10b") is available to be
+%% started using start_node/3.
+
+is_release_available(Release) ->
+ controller_call({is_release_available,Release}).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% stop_node(Name) -> ok | {error,Reason}
+%%
+%% Clean up - test_server will stop this node
+
+stop_node(Slave) ->
+ controller_call({stop_node,Slave}).
+
+
+%%--------------------------------------------------------------------
+%% Functions handling target communication over socket
+
+%% Generic send function for communication with target
+request(Sock,Request) ->
+ gen_tcp:send(Sock,<<1,(term_to_binary(Request))/binary>>).
+
+%% Receive and decode request on job specific socket
+%% Used when test is running on a remote target
+read_job_sock_loop(Sock) ->
+ case gen_tcp:recv(Sock,0) of
+ {error,Reason} ->
+ gen_tcp:close(Sock),
+ exit({controller,connection_lost,Reason});
+ {ok,<<1,Request/binary>>} ->
+ case decode(binary_to_term(Request)) of
+ ok ->
+ read_job_sock_loop(Sock);
+ {stop,Result} ->
+ Result
+ end
+ end.
+
+decode({apply,{M,F,A}}) ->
+ apply(M,F,A),
+ ok;
+decode({sync_apply,{M,F,A}}) ->
+ R = apply(M,F,A),
+ request(get(test_server_ctrl_job_sock),{sync_result,R}),
+ ok;
+decode({sync_result,Result}) ->
+ {stop,Result};
+decode({test_case_result,Result}) ->
+ {stop,Result};
+decode({privdir,empty_priv_dir}) ->
+ {stop,ok};
+decode({{privdir,PrivDirTar},TarBin}) ->
+ Root = get(test_server_log_dir_base),
+ unpack_tar(Root,PrivDirTar,TarBin),
+ {stop,ok};
+decode({crash_dumps,no_crash_dumps}) ->
+ {stop,ok};
+decode({{crash_dumps,CrashDumpTar},TarBin}) ->
+ Dir = test_server_sup:crash_dump_dir(),
+ unpack_tar(Dir,CrashDumpTar,TarBin),
+ {stop,ok}.
+
+unpack_tar(Dir,TarFileName0,TarBin) ->
+ TarFileName = filename:join(Dir,TarFileName0),
+ ok = file:write_file(TarFileName,TarBin),
+ ok = erl_tar:extract(TarFileName,[compressed,{cwd,Dir}]),
+ ok = file:delete(TarFileName).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% DEBUGGER INTERFACE %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+i() ->
+ hformat("Pid", "Initial Call", "Current Function", "Reducts", "Msgs"),
+ Line=lists:duplicate(27, "-"),
+ hformat(Line, Line, Line, Line, Line),
+ display_info(processes(), 0, 0).
+
+p(A,B,C) ->
+ pinfo(ts_pid(A,B,C)).
+p(X) when is_atom(X) ->
+ pinfo(whereis(X));
+p({A,B,C}) ->
+ pinfo(ts_pid(A,B,C));
+p(X) ->
+ pinfo(X).
+
+t() ->
+ t(wall_clock).
+t(X) ->
+ element(1, statistics(X)).
+
+pi(Item,X) ->
+ lists:keysearch(Item,1,p(X)).
+pi(Item,A,B,C) ->
+ lists:keysearch(Item,1,p(A,B,C)).
+
+%% c:pid/3
+ts_pid(X,Y,Z) when is_integer(X), is_integer(Y), is_integer(Z) ->
+ list_to_pid("<" ++ integer_to_list(X) ++ "." ++
+ integer_to_list(Y) ++ "." ++
+ integer_to_list(Z) ++ ">").
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% display_info(Pids, Reductions, Messages) -> void
+%% Pids = [pid(),...]
+%% Reductions = integer()
+%% Messaged = integer()
+%%
+%% Displays info, similar to c:i() about the processes in the list Pids.
+%% Also counts the total number of reductions and msgs for the listed
+%% processes, if called with Reductions = Messages = 0.
+
+display_info([Pid|T], R, M) ->
+ case pinfo(Pid) of
+ undefined ->
+ display_info(T, R, M);
+ Info ->
+ Call = fetch(initial_call, Info),
+ Curr = case fetch(current_function, Info) of
+ {Mod,F,Args} when is_list(Args) ->
+ {Mod,F,length(Args)};
+ Other ->
+ Other
+ end,
+ Reds = fetch(reductions, Info),
+ LM = length(fetch(messages, Info)),
+ pformat(io_lib:format("~w", [Pid]),
+ io_lib:format("~w", [Call]),
+ io_lib:format("~w", [Curr]), Reds, LM),
+ display_info(T, R+Reds, M + LM)
+ end;
+display_info([], R, M) ->
+ Line=lists:duplicate(27, "-"),
+ hformat(Line, Line, Line, Line, Line),
+ pformat("Total", "", "", R, M).
+
+hformat(A1, A2, A3, A4, A5) ->
+ io:format("~-10s ~-27s ~-27s ~8s ~4s~n", [A1,A2,A3,A4,A5]).
+
+pformat(A1, A2, A3, A4, A5) ->
+ io:format("~-10s ~-27s ~-27s ~8w ~4w~n", [A1,A2,A3,A4,A5]).
+
+fetch(Key, Info) ->
+ case lists:keysearch(Key, 1, Info) of
+ {value, {_, Val}} ->
+ Val;
+ _ ->
+ 0
+ end.
+
+pinfo(P) ->
+ Node = node(),
+ case node(P) of
+ Node ->
+ process_info(P);
+ _ ->
+ rpc:call(node(P),erlang,process_info,[P])
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Support functions for COVER %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% A module is included in the cover analysis if
+%% - it belongs to the tested application and is not listed in the
+%% {exclude,List} part of the App.cover file
+%% - it does not belong to the application, but is listed in the
+%% {include,List} part of the App.cover file
+%% - it does not belong to the application, but is listed in the
+%% cross.cover file (in the test_server application) under 'all'
+%% or under the tested application.
+%%
+%% The modules listed in the cross.cover file are modules that are
+%% hevily used by other applications than the one they belong
+%% to. After all tests are completed, these modules can be analysed
+%% with coverage data from all tests - see cross_cover_analyse/1. The
+%% result is stored in a file called cross_cover.html in the
+%% run.<timestamp> directory of the application the modules belong
+%% to.
+%%
+%% For example, the lists module is listed in cross.cover to be
+%% included in all tests. lists belongs to the stdlib
+%% application. cross_cover_analyse/1 will create a file named
+%% cross_cover.html under the newest stdlib.logs/run.xxx directory,
+%% where the coverage result for the lists module from all tests is
+%% presented.
+%%
+%% The lists module is also presented in the normal coverage log
+%% for stdlib, but that only includes the coverage achieved by
+%% the stdlib tests themselves.
+%%
+%% The Cross cover file cross.cover contains elements like this:
+%% {App,Modules}.
+%% where App can be an application name or the atom all. The
+%% application (or all applications) shall cover compile the listed
+%% Modules.
+
+
+%% Cover compilation
+%% The compilation is executed on the target node
+cover_compile({App,{_File,Exclude,Include,Cross,_Export}}) ->
+ cover_compile1({App,Exclude,Include,Cross});
+
+cover_compile({App,CoverFile}) ->
+ Cross = get_cross_modules(App),
+ {Exclude,Include} = read_cover_file(CoverFile),
+ cover_compile1({App,Exclude,Include,Cross}).
+
+cover_compile1(What) ->
+ case get(test_server_ctrl_job_sock) of
+ undefined ->
+ %% local target
+ test_server:cover_compile(What);
+ JobSock ->
+ %% remote target
+ request(JobSock, {sync_apply,{test_server,cover_compile,[What]}}),
+ read_job_sock_loop(JobSock)
+ end.
+
+
+%% Read the coverfile for an application and return a list of modules
+%% that are members of the application but shall not be compiled
+%% (Exclude), and a list of modules that are not members of the
+%% application but shall be compiled (Include).
+read_cover_file(none) ->
+ {[],[]};
+read_cover_file(CoverFile) ->
+ case file:consult(CoverFile) of
+ {ok,List} ->
+ case check_cover_file(List, [], []) of
+ {ok,Exclude,Include} -> {Exclude,Include};
+ error ->
+ io:fwrite("Faulty format of CoverFile ~p\n", [CoverFile]),
+ {[],[]}
+ end;
+ {error,Reason} ->
+ io:fwrite("Can't read CoverFile ~p\nReason: ~p\n",
+ [CoverFile,Reason]),
+ {[],[]}
+ end.
+
+check_cover_file([{exclude,all}|Rest], _, Include) ->
+ check_cover_file(Rest, all, Include);
+check_cover_file([{exclude,Exclude}|Rest], _, Include) ->
+ case lists:all(fun(M) -> is_atom(M) end, Exclude) of
+ true ->
+ check_cover_file(Rest, Exclude, Include);
+ false ->
+ error
+ end;
+check_cover_file([{include,Include}|Rest], Exclude, _) ->
+ case lists:all(fun(M) -> is_atom(M) end, Include) of
+ true ->
+ check_cover_file(Rest, Exclude, Include);
+ false ->
+ error
+ end;
+check_cover_file([], Exclude, Include) ->
+ {ok,Exclude,Include}.
+
+
+
+%% Cover analysis, per application
+%% This analysis is executed on the target node once the test is
+%% completed for an application. This is not the same as the cross
+%% cover analysis, which can be executed on any node after the tests
+%% are finshed.
+%%
+%% This per application analysis writes the file cover.html in the
+%% application's run.<timestamp> directory.
+cover_analyse({App,CoverInfo}, Analyse, AnalyseMods, TestDir) ->
+ write_default_cross_coverlog(TestDir),
+
+ {ok,CoverLog} = file:open(filename:join(TestDir, ?coverlog_name), [write]),
+ write_coverlog_header(CoverLog),
+ io:fwrite(CoverLog, "<h1>Coverage for application '~w'</h1>\n", [App]),
+ io:fwrite(CoverLog,
+ "<p><a href=\"~s\">Coverdata collected over all tests</a></p>",
+ [?cross_coverlog_name]),
+
+ {CoverFile,_Included,Excluded} =
+ case CoverInfo of
+ {File,Excl,Incl,_Cross,Export} ->
+ cover:export(Export),
+ {File,Incl,Excl};
+ File ->
+ {Excl,Incl} = read_cover_file(File),
+ {File,Incl,Excl}
+ end,
+ io:fwrite(CoverLog, "<p>CoverFile: <code>~p</code>\n", [CoverFile]),
+
+ case length(cover:imported_modules()) of
+ Imps when Imps > 0 ->
+ io:fwrite(CoverLog, "<p>Analysis includes data from ~w imported module(s).\n",
+ [Imps]);
+ _ ->
+ ok
+ end,
+
+ io:fwrite(CoverLog, "<p>Excluded module(s): <code>~p</code>\n", [Excluded]),
+
+ Coverage = cover_analyse(Analyse, AnalyseMods),
+
+ case lists:filter(fun({_M,{_,_,_}}) -> false;
+ (_) -> true
+ end, Coverage) of
+ [] ->
+ ok;
+ Bad ->
+ io:fwrite(CoverLog, "<p>Analysis failed for ~w module(s): "
+ "<code>~w</code>\n",
+ [length(Bad),[BadM || {BadM,{_,_Why}} <- Bad]])
+ end,
+
+ TotPercent = write_cover_result_table(CoverLog, Coverage),
+ file:write_file(filename:join(TestDir, ?cover_total),
+ term_to_binary(TotPercent)).
+
+cover_analyse(Analyse, AnalyseMods) ->
+ TestDir = get(test_server_log_dir_base),
+ case get(test_server_ctrl_job_sock) of
+ undefined ->
+ %% local target
+ test_server:cover_analyse({Analyse,TestDir}, AnalyseMods);
+ JobSock ->
+ %% remote target
+ request(JobSock, {sync_apply,{test_server,
+ cover_analyse,
+ [Analyse,AnalyseMods]}}),
+ read_job_sock_loop(JobSock)
+ end.
+
+
+%% Cover analysis, cross application
+%% This can be executed on any node after all tests are finished.
+%% The node's current directory must be the same as when the tests
+%% were run.
+cross_cover_analyse(Analyse) ->
+ cross_cover_analyse(Analyse, undefined).
+
+cross_cover_analyse(Analyse, CrossModules) ->
+ CoverdataFiles = get_coverdata_files(),
+ lists:foreach(fun(CDF) -> cover:import(CDF) end, CoverdataFiles),
+ io:fwrite("Cover analysing... ", []),
+ DetailsFun =
+ case Analyse of
+ details ->
+ fun(Dir,M) ->
+ OutFile = filename:join(Dir,
+ atom_to_list(M) ++
+ ".CROSS_COVER.html"),
+ cover:analyse_to_file(M, OutFile, [html]),
+ {file,OutFile}
+ end;
+ _ ->
+ fun(_,_) -> undefined end
+ end,
+ SortedModules =
+ case CrossModules of
+ undefined ->
+ sort_modules([Mod || Mod <- get_all_cross_modules(),
+ lists:member(Mod, cover:imported_modules())], []);
+ _ ->
+ sort_modules(CrossModules, [])
+ end,
+ Coverage = analyse_apps(SortedModules, DetailsFun, []),
+ cover:stop(),
+ write_cross_cover_logs(Coverage).
+
+%% For each application from which there are modules listed in the
+%% cross.cover, write a cross cover log (cross_cover.html).
+write_cross_cover_logs([{App,Coverage}|T]) ->
+ case last_test_for_app(App) of
+ false ->
+ ok;
+ Dir ->
+ CoverLogName = filename:join(Dir,?cross_coverlog_name),
+ {ok,CoverLog} = file:open(CoverLogName, [write]),
+ write_coverlog_header(CoverLog),
+ io:fwrite(CoverLog,
+ "<h1>Coverage results for \'~w\' from all tests</h1>\n",
+ [App]),
+ write_cover_result_table(CoverLog, Coverage),
+ io:fwrite("Written file ~p\n", [CoverLogName])
+ end,
+ write_cross_cover_logs(T);
+write_cross_cover_logs([]) ->
+ io:fwrite("done\n", []).
+
+%% Find all exported coverdata files. First find all the latest
+%% run.<timestamp> directories, and the check if there is a file named
+%% all.coverdata.
+get_coverdata_files() ->
+ PossibleFiles = [last_coverdata_file(Dir) ||
+ Dir <- filelib:wildcard([$*|?logdir_ext]),
+ filelib:is_dir(Dir)],
+ [File || File <- PossibleFiles, filelib:is_file(File)].
+
+last_coverdata_file(Dir) ->
+ LastDir = last_test(filelib:wildcard(filename:join(Dir,"run.[1-2]*")),false),
+ filename:join(LastDir,"all.coverdata").
+
+
+%% Find the latest run.<timestamp> directory for the given application.
+last_test_for_app(App) ->
+ AppLogDir = atom_to_list(App)++?logdir_ext,
+ last_test(filelib:wildcard(filename:join(AppLogDir,"run.[1-2]*")),false).
+
+last_test([Run|Rest], false) ->
+ last_test(Rest, Run);
+last_test([Run|Rest], Latest) when Run > Latest ->
+ last_test(Rest, Run);
+last_test([_|Rest], Latest) ->
+ last_test(Rest, Latest);
+last_test([], Latest) ->
+ Latest.
+
+%% Sort modules according to the application they belong to.
+%% Return [{App,LastTestDir,ModuleList}]
+sort_modules([M|Modules], Acc) ->
+ App = get_app(M),
+ Acc1 =
+ case lists:keysearch(App, 1, Acc) of
+ {value,{App,LastTest,List}} ->
+ lists:keyreplace(App, 1, Acc, {App,LastTest,[M|List]});
+ false ->
+ [{App,last_test_for_app(App),[M]}|Acc]
+ end,
+ sort_modules(Modules, Acc1);
+sort_modules([], Acc) ->
+ Acc.
+
+get_app(Module) ->
+ Beam = code:which(Module),
+ AppDir = filename:basename(filename:dirname(filename:dirname(Beam))),
+ [AppStr|_] = string:tokens(AppDir,"-"),
+ list_to_atom(AppStr).
+
+
+%% For each application, analyse all modules
+%% Used for cross cover analysis.
+analyse_apps([{App,LastTest,Modules}|T], DetailsFun, Acc) ->
+ Cov = analyse_modules(LastTest, Modules, DetailsFun, []),
+ analyse_apps(T, DetailsFun, [{App,Cov}|Acc]);
+analyse_apps([], _DetailsFun, Acc) ->
+ Acc.
+
+%% Analyse each module
+%% Used for cross cover analysis.
+analyse_modules(Dir, [M|Modules], DetailsFun, Acc) ->
+ {ok,{M,{Cov,NotCov}}} = cover:analyse(M, module),
+ Acc1 = [{M,{Cov,NotCov,DetailsFun(Dir,M)}}|Acc],
+ analyse_modules(Dir, Modules, DetailsFun, Acc1);
+analyse_modules(_Dir, [], _DetailsFun, Acc) ->
+ Acc.
+
+
+%% Read the cross cover file (cross.cover)
+get_all_cross_modules() ->
+ get_cross_modules(all).
+get_cross_modules(App) ->
+ case file:consult(?cross_cover_file) of
+ {ok,List} ->
+ get_cross_modules(App, List, []);
+ _X ->
+ []
+ end.
+
+get_cross_modules(App, [{_To,Modules}|T], Acc) when App==all->
+ get_cross_modules(App, T, Acc ++ Modules);
+get_cross_modules(App, [{To,Modules}|T], Acc) when To==App; To==all->
+ get_cross_modules(App, T, Acc ++ Modules);
+get_cross_modules(App, [_H|T], Acc) ->
+ get_cross_modules(App, T, Acc);
+get_cross_modules(_App, [], Acc) ->
+ Acc.
+
+
+%% Support functions for writing the cover logs (both cross and normal)
+write_coverlog_header(CoverLog) ->
+ case catch
+ io:fwrite(CoverLog,
+ "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '~w'. -->\n"
+ "<html>\n"
+ "<head><title>Coverage results</title></head>\n"
+ "<body bgcolor=\"white\" text=\"black\" "
+ "link=\"blue\" vlink=\"purple\" alink=\"red\">",
+ [?MODULE]) of
+ {'EXIT',Reason} ->
+ io:format("\n\nERROR: Could not write normal heading in coverlog.\n"
+ "CoverLog: ~w\n"
+ "Reason: ~p\n",
+ [CoverLog,Reason]),
+ io:format(CoverLog,"<html><body>\n", []);
+ _ ->
+ ok
+ end.
+
+
+format_analyse(M,Cov,NotCov,undefined) ->
+ io_lib:fwrite("<tr><td>~w</td>"
+ "<td align=right>~w %</td>"
+ "<td align=right>~w</td>"
+ "<td align=right>~w</td></tr>\n",
+ [M,pc(Cov,NotCov),Cov,NotCov]);
+format_analyse(M,Cov,NotCov,{file,File}) ->
+ io_lib:fwrite("<tr><td><a href=\"~s\">~w</a></td>"
+ "<td align=right>~w %</td>"
+ "<td align=right>~w</td>"
+ "<td align=right>~w</td></tr>\n",
+ [filename:basename(File),M,pc(Cov,NotCov),Cov,NotCov]);
+format_analyse(M,Cov,NotCov,{lines,Lines}) ->
+ CoverOutName = atom_to_list(M)++".COVER.html",
+ {ok,CoverOut} = file:open(CoverOutName, [write]),
+ write_not_covered(CoverOut,M,Lines),
+ io_lib:fwrite("<tr><td><a href=\"~s\">~w</a></td>"
+ "<td align=right>~w %</td>"
+ "<td align=right>~w</td>"
+ "<td align=right>~w</td></tr>\n",
+ [CoverOutName,M,pc(Cov,NotCov),Cov,NotCov]);
+format_analyse(M,Cov,NotCov,{error,_}) ->
+ io_lib:fwrite("<tr><td>~w</td>"
+ "<td align=right>~w %</td>"
+ "<td align=right>~w</td>"
+ "<td align=right>~w</td></tr>\n",
+ [M,pc(Cov,NotCov),Cov,NotCov]).
+
+
+pc(0,0) ->
+ 0;
+pc(Cov,NotCov) ->
+ round(Cov/(Cov+NotCov)*100).
+
+
+write_not_covered(CoverOut,M,Lines) ->
+ io:fwrite(CoverOut,
+ "<html>\n"
+ "The following lines in module ~w are not covered:\n"
+ "<table border=3 cellpadding=5>\n"
+ "<th>Line Number</th>\n",
+ [M]),
+ lists:foreach(fun({{_M,Line},{0,1}}) ->
+ io:fwrite(CoverOut,"<tr><td>~w</td></tr>\n", [Line]);
+ (_) ->
+ ok
+ end,
+ Lines),
+ io:fwrite(CoverOut,"</table>\n</html>\n", []).
+
+
+write_default_coverlog(TestDir) ->
+ {ok,CoverLog} = file:open(filename:join(TestDir,?coverlog_name), [write]),
+ write_coverlog_header(CoverLog),
+ io:fwrite(CoverLog,"Cover tool is not used\n</body></html>\n", []),
+ file:close(CoverLog).
+
+write_default_cross_coverlog(TestDir) ->
+ {ok,CrossCoverLog} =
+ file:open(filename:join(TestDir,?cross_coverlog_name), [write]),
+ write_coverlog_header(CrossCoverLog),
+ io:fwrite(CrossCoverLog,
+ "No cross cover modules exist for this application,<br>"
+ "or cross cover analysis is not completed.\n"
+ "</body></html>\n", []),
+ file:close(CrossCoverLog).
+
+write_cover_result_table(CoverLog,Coverage) ->
+ io:fwrite(CoverLog,
+ "<p><table border=3 cellpadding=5>\n"
+ "<tr><th>Module</th><th>Covered (%)</th><th>Covered (Lines)</th>"
+ "<th>Not covered (Lines)</th>\n",
+ []),
+ {TotCov,TotNotCov} =
+ lists:foldl(fun({M,{Cov,NotCov,Details}},{AccCov,AccNotCov}) ->
+ Str = format_analyse(M,Cov,NotCov,Details),
+ io:fwrite(CoverLog,"~s", [Str]),
+ {AccCov+Cov,AccNotCov+NotCov};
+ ({_M,{error,_Reason}},{AccCov,AccNotCov}) ->
+ {AccCov,AccNotCov}
+ end,
+ {0,0},
+ Coverage),
+ TotPercent = pc(TotCov,TotNotCov),
+ io:fwrite(CoverLog,
+ "<tr><th align=left>Total</th><th align=right>~w %</th>"
+ "<th align=right>~w</th><th align=right>~w</th></tr>\n"
+ "</table>\n"
+ "</body>\n"
+ "</html>\n",
+ [TotPercent,TotCov,TotNotCov]),
+ file:close(CoverLog),
+ TotPercent.
diff --git a/lib/test_server/src/test_server_h.erl b/lib/test_server/src/test_server_h.erl
new file mode 100644
index 0000000000..e423863b99
--- /dev/null
+++ b/lib/test_server/src/test_server_h.erl
@@ -0,0 +1,129 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2005-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+-module(test_server_h).
+-behaviour(gen_event).
+
+%% API
+-export([install/0, restore/0]).
+-export([testcase/1]).
+
+%% gen_event callbacks
+-export([init/1, handle_event/2, handle_call/2,
+ handle_info/2, terminate/2, code_change/3]).
+
+-record(state, {kernel, sasl, testcase}).
+
+%%====================================================================
+%% API
+%%====================================================================
+
+install() ->
+ case gen_event:add_handler(error_logger, ?MODULE, []) of
+ ok ->
+ error_logger:delete_report_handler(sasl_report_tty_h),
+ gen_event:delete_handler(error_logger, error_logger_tty_h, []),
+ ok;
+ Error ->
+ Error
+ end.
+
+restore() ->
+ gen_event:add_handler(error_logger, error_logger_tty_h, []),
+ error_logger:add_report_handler(sasl_report_tty_h, all),
+ gen_event:delete_handler(error_logger, ?MODULE, []).
+
+testcase(Testcase) ->
+ gen_event:call(error_logger, ?MODULE, {set_testcase, Testcase}, 10*60*1000).
+
+%%====================================================================
+%% gen_event callbacks
+%%====================================================================
+
+init([]) ->
+
+ %% error_logger_tty_h initialization
+ User = set_group_leader(),
+
+ %% sasl_report_tty_h initialization
+ Type = all,
+
+ {ok, #state{kernel={User, []}, sasl=Type}}.
+
+set_group_leader() ->
+ case whereis(user) of
+ User when is_pid(User) ->
+ link(User),
+ group_leader(User, self()),
+ User;
+ _ ->
+ false
+ end.
+
+handle_event({_Type, GL, _Msg}, State) when node(GL)/=node() ->
+ {ok, State};
+handle_event({Tag, _GL, {_Pid, Type, _Report}} = Event, State) ->
+ case report(Tag, Type) of
+ sasl ->
+ tag(State#state.testcase),
+ sasl_report_tty_h:handle_event(Event, State#state.sasl);
+ kernel ->
+ tag(State#state.testcase),
+ error_logger_tty_h:handle_event(Event, State#state.kernel);
+ none ->
+ ignore
+ end,
+ {ok, State};
+handle_event(_Event, State) ->
+ {ok, State}.
+
+handle_call({set_testcase, Testcase}, State) ->
+ {ok, ok, State#state{testcase=Testcase}};
+handle_call(_Query, _State) ->
+ {error, bad_query}.
+
+handle_info({emulator,GL,_Chars}=Event, State) when node(GL)==node() ->
+ tag(State#state.testcase),
+ error_logger_tty_h:handle_info(Event, State#state.kernel),
+ {ok, State};
+handle_info(_Msg, State) ->
+ {ok, State}.
+
+terminate(_Reason, _State) ->
+ ok.
+
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+report(error_report, supervisor_report) -> sasl;
+report(error_report, crash_report) -> sasl;
+report(info_report, progress) -> sasl;
+report(error, _) -> kernel;
+report(error_report, _) -> kernel;
+report(warning_msg, _) -> kernel;
+report(warning_report, _) -> kernel;
+report(info, _) -> kernel;
+report(info_msg, _) -> kernel;
+report(info_report, _) -> kernel;
+report(_, _) -> none.
+
+tag({M,F,A}) when is_atom(M), is_atom(F), is_integer(A) ->
+ io:format(user, "~n=TESTCASE: ~p:~p/~p", [M,F,A]);
+tag(Testcase) ->
+ io:format(user, "~n=TESTCASE: ~p", [Testcase]).
diff --git a/lib/test_server/src/test_server_internal.hrl b/lib/test_server/src/test_server_internal.hrl
new file mode 100644
index 0000000000..6fa5ef75b1
--- /dev/null
+++ b/lib/test_server/src/test_server_internal.hrl
@@ -0,0 +1,59 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2002-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+-define(priv_dir,"log_private").
+-define(MAIN_PORT,3289).
+-define(ACCEPT_TIMEOUT,20000).
+
+%% Target information generated by test_server:init_target_info/0 and
+%% test_server_ctrl:contact_main_target/2
+%% Once initiated, this information will never change!!
+-record(target_info, {where, % local | Socket
+ os_family, % atom(); win32 | unix | vxworks | ose
+ os_type, % result of os:type()
+ host, % string(); the name of the target machine
+ version, % string()
+ system_version, % string()
+ root_dir, % string()
+ test_server_dir, % string()
+ emulator, % string()
+ otp_release, % string()
+ username, % string()
+ cookie, % string(); Cookie for target node
+ naming, % string(); "-name" | "-sname"
+ master, % string(); For OSE this is the master
+ % node for main target and slave nodes.
+ % For other platforms the target node
+ % itself is master for slave nodes
+
+ %% The following are only used for remote targets
+ target_client, % reference to a client talking to target
+ slave_targets=[]}).% list() of atom(); all available
+ % targets for starting slavenodes
+
+%% Temporary information generated by test_server_ctrl:read_parameters/X
+%% This information is used when starting the main target, and for
+%% initiating the #target_info record.
+-record(par, {type,
+ target,
+ slave_targets=[],
+ naming,
+ master,
+ cookie}).
+
diff --git a/lib/test_server/src/test_server_line.erl b/lib/test_server/src/test_server_line.erl
new file mode 100644
index 0000000000..26ef3a3040
--- /dev/null
+++ b/lib/test_server/src/test_server_line.erl
@@ -0,0 +1,380 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2004-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(test_server_line).
+
+%% User interface
+-export([get_lines/0]).
+-export([clear/0]).
+
+%% Parse transform functions
+-export([parse_transform/2]).
+-export(['$test_server_line'/3]).
+-export(['$test_server_lineQ'/3]).
+-export([trace_line/3]).
+
+-define(TEST_SERVER_LINE_SIZE, 10).
+%-define(STORAGE_FUNCTION, '$test_server_line').
+-define(STORAGE_FUNCTION, '$test_server_lineQ').
+
+-include("test_server.hrl").
+
+-record(vars, {module, % atom() Module name
+ function, % atom() Function name
+ arity, % int() Function arity
+ lines, % [int()] seen lines
+ is_guard=false, % boolean()
+ no_lines=[], % [{atom(),integer()}]
+ % Functions to exclude
+ line_trace=false
+ }).
+
+
+
+
+%% Process dictionary littering variant
+%%
+
+'$test_server_line'(Mod, Func, Line) ->
+ {Prev,Next} =
+ case get('$test_server_line') of
+ I when is_integer(I) ->
+ if 1 =< I, I < ?TEST_SERVER_LINE_SIZE -> {I,I+1};
+ true -> {?TEST_SERVER_LINE_SIZE,1}
+ end;
+ _ -> {?TEST_SERVER_LINE_SIZE,1}
+ end,
+ PrevTag = {'$test_server_line',Prev},
+ case get(PrevTag) of
+ {Mod,Func,_} -> put(PrevTag, {Mod,Func,Line});
+ _ ->
+ put({'$test_server_line',Next}, {Mod,Func,Line}),
+ put('$test_server_line', Next)
+ end, ok.
+
+test_server_line_get() ->
+ case get('$test_server_line') of
+ I when is_integer(I), 1 =< I, I =< ?TEST_SERVER_LINE_SIZE ->
+ test_server_line_get_1(?TEST_SERVER_LINE_SIZE, I, []);
+ _ -> []
+ end.
+
+test_server_line_get_1(0, _I, R) ->
+ R;
+test_server_line_get_1(Cnt, I, R) ->
+ J = if I < ?TEST_SERVER_LINE_SIZE -> I+1;
+ true -> 1 end,
+ case get({'$test_server_line',J}) of
+ undefined ->
+ %% Less than ?TEST_SERVER_LINE_SIZE number of lines stored
+ %% Start from line 1 and stop at actutual number of lines
+ case get({'$test_server_line',1}) of
+ undefined -> R; % no lines at all stored
+ E -> test_server_line_get_1(I-1,1,[E|R])
+ end;
+ E ->
+ test_server_line_get_1(Cnt-1, J, [E|R])
+ end.
+
+test_server_line_clear() ->
+ Is = lists:seq(1,?TEST_SERVER_LINE_SIZE),
+ lists:foreach(fun (I) -> erase({'$test_server_line',I}) end, Is),
+ erase('$test_server_line'),
+ ok.
+
+
+%% Queue variant, uses just one process dictionary entry
+%%
+
+'$test_server_lineQ'(Mod, Func, Line) ->
+ case get('$test_server_lineQ') of
+ {I,Q} when is_integer(I), 1 =< I, I =< ?TEST_SERVER_LINE_SIZE ->
+ case queue:head(Q) of
+ {Mod,Func,_} ->
+ %% Replace queue head
+ put('$test_server_lineQ',
+ {I,queue:cons({Mod,Func,Line}, queue:tail(Q))});
+ _ when I < ?TEST_SERVER_LINE_SIZE ->
+ put('$test_server_lineQ',
+ {I+1,queue:cons({Mod,Func,Line}, Q)});
+ _ ->
+ %% Waste last in queue
+ put('$test_server_lineQ',
+ {I,queue:cons({Mod,Func,Line}, queue:lait(Q))})
+ end;
+ _ ->
+ Q = queue:new(),
+ put('$test_server_lineQ', {1,queue:cons({Mod,Func,Line}, Q)})
+ end, ok.
+
+%test_server_lineQ_get() ->
+% case get('$test_server_lineQ') of
+% {I,Q} when integer(I), 1 =< I, I =< ?TEST_SERVER_LINE_SIZE ->
+% queue:to_list(Q);
+% _ -> []
+% end.
+
+test_server_lineQ_clear() ->
+ erase('$test_server_lineQ'),
+ ok.
+
+
+%% Get line - check if queue or dictionary is used, then get the lines
+%%
+
+get_lines() ->
+ case get('$test_server_lineQ') of
+ {I,Q} when is_integer(I), 1 =< I, I =< ?TEST_SERVER_LINE_SIZE ->
+ queue:to_list(Q);
+ _ ->
+ test_server_line_get()
+ end.
+
+%% Clear all dictionary entries
+%%
+clear() ->
+ test_server_line_clear(),
+ test_server_lineQ_clear().
+
+
+trace_line(Mod,Func,Line) ->
+ io:format(lists:concat([Mod,":",Func,",",integer_to_list(Line),": ~p"]),
+ [erlang:now()]).
+
+
+%%%=================================================================
+%%%========= **** PARSE TRANSFORM **** ========================
+%%%=================================================================
+parse_transform(Forms, _Options) ->
+ transform(Forms, _Options).
+
+%% forms(Fs) -> lists:map(fun (F) -> form(F) end, Fs).
+
+transform(Forms, _Options)->
+ Vars0 = #vars{},
+ {ok, MungedForms, _Vars} = transform(Forms, [], Vars0),
+ MungedForms.
+
+
+transform([Form|Forms], MungedForms, Vars) ->
+ case munge(Form, Vars) of
+ ignore ->
+ transform(Forms, MungedForms, Vars);
+ {MungedForm, Vars2} ->
+ transform(Forms, [MungedForm|MungedForms], Vars2)
+ end;
+transform([], MungedForms, Vars) ->
+ {ok, lists:reverse(MungedForms), Vars}.
+
+%% This code traverses the abstract code, stored as the abstract_code
+%% chunk in the BEAM file, as described in absform(3) for Erlang/OTP R8B
+%% (Vsn=abstract_v2).
+%% The abstract format after preprocessing differs slightly from the abstract
+%% format given eg using epp:parse_form, this has been noted in comments.
+munge(Form={attribute,_,module,Module}, Vars) ->
+ Vars2 = Vars#vars{module=Module},
+ {Form, Vars2};
+
+munge(Form={attribute,_,no_lines,Funcs}, Vars) ->
+ Vars2 = Vars#vars{no_lines=Funcs},
+ {Form, Vars2};
+
+munge(Form={attribute,_,line_trace,_}, Vars) ->
+ Vars2 = Vars#vars{line_trace=true},
+ {Form, Vars2};
+
+munge({function,0,module_info,_Arity,_Clauses}, _Vars) ->
+ ignore; % module_info will be added again when the forms are recompiled
+munge(Form = {function,Line,Function,Arity,Clauses}, Vars) ->
+ case lists:member({Function,Arity},Vars#vars.no_lines) of
+ true ->
+ %% Line numbers in this function shall not be stored
+ {Form,Vars};
+ false ->
+ Vars2 = Vars#vars{function=Function,
+ arity=Arity,
+ lines=[]},
+ {MungedClauses, Vars3} = munge_clauses(Clauses, Vars2, []),
+ {{function,Line,Function,Arity,MungedClauses}, Vars3}
+ end;
+munge(Form, Vars) -> % attributes
+ {Form, Vars}.
+
+munge_clauses([{clause,Line,Pattern,Guards,Body}|Clauses], Vars, MClauses) ->
+ {MungedGuards, _Vars} = munge_exprs(Guards, Vars#vars{is_guard=true},[]),
+ {MungedBody, Vars2} = munge_body(Body, Vars, []),
+ munge_clauses(Clauses, Vars2,
+ [{clause,Line,Pattern,MungedGuards,MungedBody}|
+ MClauses]);
+munge_clauses([], Vars, MungedClauses) ->
+ {lists:reverse(MungedClauses), Vars}.
+
+munge_body([Expr|Body], Vars, MungedBody) ->
+ %% Here is the place to add a call to storage function!
+ Line = element(2, Expr),
+ Lines = Vars#vars.lines,
+ case lists:member(Line,Lines) of
+ true -> % already a bump at this line!
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ munge_body(Body, Vars2, [MungedExpr|MungedBody]);
+ false ->
+ Bump = {call, 0, {remote,0,
+ {atom,0,?MODULE},
+ {atom,0,?STORAGE_FUNCTION}},
+ [{atom,0,Vars#vars.module},
+ {atom, 0, Vars#vars.function},
+ {integer, 0, Line}]},
+ Lines2 = [Line|Lines],
+
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars#vars{lines=Lines2}),
+ MungedBody2 =
+ if Vars#vars.line_trace ->
+ LineTrace = {call, 0, {remote,0,
+ {atom,0,?MODULE},
+ {atom,0,trace_line}},
+ [{atom,0,Vars#vars.module},
+ {atom, 0, Vars#vars.function},
+ {integer, 0, Line}]},
+ [MungedExpr,LineTrace,Bump|MungedBody];
+ true ->
+ [MungedExpr,Bump|MungedBody]
+ end,
+ munge_body(Body, Vars2, MungedBody2)
+ end;
+munge_body([], Vars, MungedBody) ->
+ {lists:reverse(MungedBody), Vars}.
+
+munge_expr({match,Line,ExprL,ExprR}, Vars) ->
+ {MungedExprL, Vars2} = munge_expr(ExprL, Vars),
+ {MungedExprR, Vars3} = munge_expr(ExprR, Vars2),
+ {{match,Line,MungedExprL,MungedExprR}, Vars3};
+munge_expr({tuple,Line,Exprs}, Vars) ->
+ {MungedExprs, Vars2} = munge_exprs(Exprs, Vars, []),
+ {{tuple,Line,MungedExprs}, Vars2};
+munge_expr({record,Line,Expr,Exprs}, Vars) ->
+ %% Only for Vsn=raw_abstract_v1
+ {MungedExprName, Vars2} = munge_expr(Expr, Vars),
+ {MungedExprFields, Vars3} = munge_exprs(Exprs, Vars2, []),
+ {{record,Line,MungedExprName,MungedExprFields}, Vars3};
+munge_expr({record_field,Line,ExprL,ExprR}, Vars) ->
+ %% Only for Vsn=raw_abstract_v1
+ {MungedExprL, Vars2} = munge_expr(ExprL, Vars),
+ {MungedExprR, Vars3} = munge_expr(ExprR, Vars2),
+ {{record_field,Line,MungedExprL,MungedExprR}, Vars3};
+munge_expr({cons,Line,ExprH,ExprT}, Vars) ->
+ {MungedExprH, Vars2} = munge_expr(ExprH, Vars),
+ {MungedExprT, Vars3} = munge_expr(ExprT, Vars2),
+ {{cons,Line,MungedExprH,MungedExprT}, Vars3};
+munge_expr({op,Line,Op,ExprL,ExprR}, Vars) ->
+ {MungedExprL, Vars2} = munge_expr(ExprL, Vars),
+ {MungedExprR, Vars3} = munge_expr(ExprR, Vars2),
+ {{op,Line,Op,MungedExprL,MungedExprR}, Vars3};
+munge_expr({op,Line,Op,Expr}, Vars) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ {{op,Line,Op,MungedExpr}, Vars2};
+munge_expr({'catch',Line,Expr}, Vars) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ {{'catch',Line,MungedExpr}, Vars2};
+munge_expr({call,Line1,{remote,Line2,ExprM,ExprF},Exprs},
+ Vars) when Vars#vars.is_guard==false->
+ {MungedExprM, Vars2} = munge_expr(ExprM, Vars),
+ {MungedExprF, Vars3} = munge_expr(ExprF, Vars2),
+ {MungedExprs, Vars4} = munge_exprs(Exprs, Vars3, []),
+ {{call,Line1,{remote,Line2,MungedExprM,MungedExprF},MungedExprs}, Vars4};
+munge_expr({call,Line1,{remote,_Line2,_ExprM,ExprF},Exprs},
+ Vars) when Vars#vars.is_guard==true ->
+ %% Difference in abstract format after preprocessing: BIF calls in guards
+ %% are translated to {remote,...} (which is not allowed as source form)
+ %% NOT NECESSARY FOR Vsn=raw_abstract_v1
+ munge_expr({call,Line1,ExprF,Exprs}, Vars);
+munge_expr({call,Line,Expr,Exprs}, Vars) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ {MungedExprs, Vars3} = munge_exprs(Exprs, Vars2, []),
+ {{call,Line,MungedExpr,MungedExprs}, Vars3};
+munge_expr({lc,Line,Expr,LC}, Vars) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ {MungedLC, Vars3} = munge_lc(LC, Vars2, []),
+ {{lc,Line,MungedExpr,MungedLC}, Vars3};
+munge_expr({block,Line,Body}, Vars) ->
+ {MungedBody, Vars2} = munge_body(Body, Vars, []),
+ {{block,Line,MungedBody}, Vars2};
+munge_expr({'if',Line,Clauses}, Vars) ->
+ {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []),
+ {{'if',Line,MungedClauses}, Vars2};
+munge_expr({'case',Line,Expr,Clauses}, Vars) ->
+ {MungedExpr,Vars2} = munge_expr(Expr,Vars),
+ {MungedClauses,Vars3} = munge_clauses(Clauses, Vars2, []),
+ {{'case',Line,MungedExpr,MungedClauses}, Vars3};
+munge_expr({'receive',Line,Clauses}, Vars) ->
+ {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []),
+ {{'receive',Line,MungedClauses}, Vars2};
+munge_expr({'receive',Line,Clauses,Expr,Body}, Vars) ->
+ {MungedClauses,Vars2} = munge_clauses(Clauses, Vars, []),
+ {MungedExpr, Vars3} = munge_expr(Expr, Vars2),
+ {MungedBody, Vars4} = munge_body(Body, Vars3, []),
+ {{'receive',Line,MungedClauses,MungedExpr,MungedBody}, Vars4};
+munge_expr({'try',Line,Exprs,Clauses,CatchClauses,After}, Vars) ->
+ {MungedExprs, Vars1} = munge_exprs(Exprs, Vars, []),
+ {MungedClauses, Vars2} = munge_clauses(Clauses, Vars1, []),
+ {MungedCatchClauses, Vars3} = munge_clauses(CatchClauses, Vars2, []),
+ {MungedAfter, Vars4} = munge_body(After, Vars3, []),
+ {{'try',Line,MungedExprs,MungedClauses,MungedCatchClauses,MungedAfter},
+ Vars4};
+%% Difference in abstract format after preprocessing: Funs get an extra
+%% element Extra.
+%% NOT NECESSARY FOR Vsn=raw_abstract_v1
+munge_expr({'fun',Line,{function,Name,Arity},_Extra}, Vars) ->
+ {{'fun',Line,{function,Name,Arity}}, Vars};
+munge_expr({'fun',Line,{clauses,Clauses},_Extra}, Vars) ->
+ {MungedClauses,Vars2}=munge_clauses(Clauses, Vars, []),
+ {{'fun',Line,{clauses,MungedClauses}}, Vars2};
+munge_expr({'fun',Line,{clauses,Clauses}}, Vars) ->
+ %% Only for Vsn=raw_abstract_v1
+ {MungedClauses,Vars2}=munge_clauses(Clauses, Vars, []),
+ {{'fun',Line,{clauses,MungedClauses}}, Vars2};
+munge_expr(Form, Vars) -> % var|char|integer|float|string|atom|nil|bin|eof
+ {Form, Vars}.
+
+munge_exprs([Expr|Exprs], Vars, MungedExprs) when Vars#vars.is_guard==true,
+ is_list(Expr) ->
+ {MungedExpr, _Vars} = munge_exprs(Expr, Vars, []),
+ munge_exprs(Exprs, Vars, [MungedExpr|MungedExprs]);
+munge_exprs([Expr|Exprs], Vars, MungedExprs) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ munge_exprs(Exprs, Vars2, [MungedExpr|MungedExprs]);
+munge_exprs([], Vars, MungedExprs) ->
+ {lists:reverse(MungedExprs), Vars}.
+
+munge_lc([{generate,Line,Pattern,Expr}|LC], Vars, MungedLC) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ munge_lc(LC, Vars2, [{generate,Line,Pattern,MungedExpr}|MungedLC]);
+munge_lc([Expr|LC], Vars, MungedLC) ->
+ {MungedExpr, Vars2} = munge_expr(Expr, Vars),
+ munge_lc(LC, Vars2, [MungedExpr|MungedLC]);
+munge_lc([], Vars, MungedLC) ->
+ {lists:reverse(MungedLC), Vars}.
+
+
+
+
+
+
+
+
+
+
diff --git a/lib/test_server/src/test_server_node.erl b/lib/test_server/src/test_server_node.erl
new file mode 100644
index 0000000000..ddc89d50d4
--- /dev/null
+++ b/lib/test_server/src/test_server_node.erl
@@ -0,0 +1,1013 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2002-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(test_server_node).
+-compile(r11).
+
+%%%
+%%% The same compiled code for this module must be possible to load
+%%% in R11B, R12B and later. To make that possible no bit syntax
+%%% must be used.
+%%%
+
+
+%% Test Controller interface
+-export([is_release_available/1]).
+-export([start_remote_main_target/1,stop/1]).
+-export([start_tracer_node/2,trace_nodes/2,stop_tracer_node/1]).
+-export([start_node/5, stop_node/2]).
+-export([kill_nodes/1, nodedown/2]).
+%% Internal export
+-export([node_started/1,trc/1,handle_debug/4]).
+
+-include("test_server_internal.hrl").
+-record(slave_info, {name,socket,client}).
+-define(VXWORKS_ACCEPT_TIMEOUT,?ACCEPT_TIMEOUT).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% %%%
+%%% All code in this module executes on the test_server_ctrl process %%%
+%%% except for node_started/1 and trc/1 which execute on a new node. %%%
+%%% %%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+is_release_available(Rel) when is_atom(Rel) ->
+ is_release_available(atom_to_list(Rel));
+is_release_available(Rel) ->
+ case os:type() of
+ {unix,_} ->
+ Erl = find_release(Rel),
+ case Erl of
+ none -> false;
+ _ -> filelib:is_regular(Erl)
+ end;
+ _ ->
+ false
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Start main target node on remote host
+%%% The target node must not know the controller node via erlang distribution.
+start_remote_main_target(Parameters) ->
+ #par{type=TargetType,
+ target=TargetHost,
+ naming=Naming,
+ master=MasterNode,
+ cookie=MasterCookie,
+ slave_targets=SlaveTargets} = Parameters,
+
+ lists:foreach(fun(T) -> maybe_reboot_target({TargetType,T}) end,
+ [list_to_atom(TargetHost)|SlaveTargets]),
+
+ % Must give the targets a chance to reboot...
+ case TargetType of
+ vxworks ->
+ receive after 15000 -> ok end;
+ _ ->
+ ok
+ end,
+
+ Cmd0 = get_main_target_start_command(TargetType,TargetHost,Naming,
+ MasterNode,MasterCookie),
+ Cmd =
+ case os:getenv("TEST_SERVER_FRAMEWORK") of
+ false -> Cmd0;
+ FW -> Cmd0 ++ " -env TEST_SERVER_FRAMEWORK " ++ FW
+ end,
+
+ {ok,LSock} = gen_tcp:listen(?MAIN_PORT,[binary,{reuseaddr,true},{packet,2}]),
+ case start_target(TargetType,TargetHost,Cmd) of
+ {ok,TargetClient,AcceptTimeout} ->
+ case gen_tcp:accept(LSock,AcceptTimeout) of
+ {ok,Sock} ->
+ gen_tcp:close(LSock),
+ receive
+ {tcp,Sock,Bin} when is_binary(Bin) ->
+ case unpack(Bin) of
+ error ->
+ gen_tcp:close(Sock),
+ close_target_client(TargetClient),
+ {error,bad_message};
+ {ok,{target_info,TI}} ->
+ put(test_server_free_targets,SlaveTargets),
+ {ok, TI#target_info{where=Sock,
+ host=TargetHost,
+ naming=Naming,
+ master=MasterNode,
+ target_client=TargetClient,
+ slave_targets=SlaveTargets}}
+ end;
+ {tcp_closed,Sock} ->
+ gen_tcp:close(Sock),
+ close_target_client(TargetClient),
+ {error,could_not_contact_target}
+ after AcceptTimeout ->
+ gen_tcp:close(Sock),
+ close_target_client(TargetClient),
+ {error,timeout}
+ end;
+ Error ->
+ %%! maybe something like kill_target(...)???
+ gen_tcp:close(LSock),
+ close_target_client(TargetClient),
+ {error,{could_not_contact_target,Error}}
+ end;
+ Error ->
+ gen_tcp:close(LSock),
+ {error,{could_not_start_target,Error}}
+ end.
+
+stop(TI) ->
+ kill_nodes(TI),
+ case TI#target_info.where of
+ local -> % there is no remote target to stop
+ ok;
+ Sock -> % stop remote target
+ gen_tcp:close(Sock),
+ close_target_client(TI#target_info.target_client)
+ end.
+
+nodedown(Sock, TI) ->
+ Match = #slave_info{name='$1',socket=Sock,client='$2',_='_'},
+ case ets:match(slave_tab,Match) of
+ [[Node,Client]] -> % Slave node died
+ gen_tcp:close(Sock),
+ ets:delete(slave_tab,Node),
+ close_target_client(Client),
+ HostAtom = test_server_sup:hostatom(Node),
+ case lists:member(HostAtom,TI#target_info.slave_targets) of
+ true ->
+ put(test_server_free_targets,
+ get(test_server_free_targets) ++ [HostAtom]);
+ false -> ok
+ end,
+ slave_died;
+ [] ->
+ case TI#target_info.where of
+ Sock ->
+ %% test_server_ctrl will do the cleanup
+ target_died;
+ _ ->
+ ignore
+ end
+ end.
+
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Start trace node
+%%%
+start_tracer_node(TraceFile,TI) ->
+ Match = #slave_info{name='$1',_='_'},
+ SlaveNodes = lists:map(fun([N]) -> [" ",N] end,
+ ets:match(slave_tab,Match)),
+ TargetNode = case TI#target_info.where of
+ local -> node();
+ _ -> "test_server@" ++ TI#target_info.host
+ end,
+ Cookie = TI#target_info.cookie,
+ {ok,LSock} = gen_tcp:listen(0,[binary,{reuseaddr,true},{packet,2}]),
+ {ok,TracePort} = inet:port(LSock),
+ Prog = pick_erl_program(default),
+ Cmd = lists:concat([Prog, " -sname tracer -hidden -setcookie ", Cookie,
+ " -s ", ?MODULE, " trc ", TraceFile, " ",
+ TracePort, " ", TI#target_info.os_family]),
+ spawn(fun() -> print_data(open_port({spawn,Cmd},[stream])) end),
+%! open_port({spawn,Cmd},[stream]),
+ case gen_tcp:accept(LSock,?ACCEPT_TIMEOUT) of
+ {ok,Sock} ->
+ gen_tcp:close(LSock),
+ receive
+ {tcp,Sock,Result} when is_binary(Result) ->
+ case unpack(Result) of
+ error ->
+ gen_tcp:close(Sock),
+ {error,timeout};
+ {ok,started} ->
+ trace_nodes(Sock,[TargetNode | SlaveNodes]),
+ {ok,Sock};
+ {ok,Error} -> Error
+ end;
+ {tcp_closed,Sock} ->
+ gen_tcp:close(Sock),
+ {error,could_not_start_tracernode}
+ after ?ACCEPT_TIMEOUT ->
+ gen_tcp:close(Sock),
+ {error,timeout}
+ end;
+ Error ->
+ gen_tcp:close(LSock),
+ {error,{could_not_start_tracernode,Error}}
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Start a tracer on each of these nodes and set flags and patterns
+%%%
+trace_nodes(Sock,Nodes) ->
+ Bin = term_to_binary({add_nodes,Nodes}),
+ ok = gen_tcp:send(Sock, [1|Bin]),
+ receive_ack(Sock).
+
+
+receive_ack(Sock) ->
+ receive
+ {tcp,Sock,Bin} when is_binary(Bin) ->
+ case unpack(Bin) of
+ error -> receive_ack(Sock);
+ {ok,_} -> ok
+ end;
+ _ ->
+ receive_ack(Sock)
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Stop trace node
+%%%
+stop_tracer_node(Sock) ->
+ Bin = term_to_binary(id(stop)),
+ ok = gen_tcp:send(Sock, [1|Bin]),
+ receive {tcp_closed,Sock} -> gen_tcp:close(Sock) end,
+ ok.
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% trc([TraceFile,Nodes]) -> ok
+%%
+%% Start tracing on the given nodes
+%%
+%% This function executes on the new node
+%%
+trc([TraceFile, PortAtom, Type]) ->
+ {Result,Patterns} =
+ case file:consult(TraceFile) of
+ {ok,TI} ->
+ Pat = parse_trace_info(lists:flatten(TI)),
+ {started,Pat};
+ Error ->
+ {Error,[]}
+ end,
+ Port = list_to_integer(atom_to_list(PortAtom)),
+ case catch gen_tcp:connect("localhost", Port, [binary,
+ {reuseaddr,true},
+ {packet,2}]) of
+ {ok,Sock} ->
+ BinResult = term_to_binary(Result),
+ ok = gen_tcp:send(Sock,[1|BinResult]),
+ trc_loop(Sock,Patterns,Type);
+ _else ->
+ ok
+ end,
+ erlang:halt().
+trc_loop(Sock,Patterns,Type) ->
+ receive
+ {tcp,Sock,Bin} ->
+ case unpack(Bin) of
+ error ->
+ ttb:stop(),
+ gen_tcp:close(Sock);
+ {ok,{add_nodes,Nodes}} ->
+ add_nodes(Nodes,Patterns,Type),
+ Bin = term_to_binary(id(ok)),
+ ok = gen_tcp:send(Sock, [1|Bin]),
+ trc_loop(Sock,Patterns,Type);
+ {ok,stop} ->
+ ttb:stop(),
+ gen_tcp:close(Sock)
+ end;
+ {tcp_closed,Sock} ->
+ ttb:stop(),
+ gen_tcp:close(Sock)
+ end.
+add_nodes(Nodes,Patterns,_Type) ->
+ ttb:tracer(Nodes,[{file,{local, test_server}},
+ {handler, {{?MODULE,handle_debug},initial}}]),
+ ttb:p(all,[call,timestamp]),
+ lists:foreach(fun({TP,M,F,A,Pat}) -> ttb:TP(M,F,A,Pat);
+ ({CTP,M,F,A}) -> ttb:CTP(M,F,A)
+ end,
+ Patterns).
+
+parse_trace_info([{TP,M,Pat}|Pats]) when TP=:=tp; TP=:=tpl ->
+ [{TP,M,'_','_',Pat}|parse_trace_info(Pats)];
+parse_trace_info([{TP,M,F,Pat}|Pats]) when TP=:=tp; TP=:=tpl ->
+ [{TP,M,F,'_',Pat}|parse_trace_info(Pats)];
+parse_trace_info([{TP,M,F,A,Pat}|Pats]) when TP=:=tp; TP=:=tpl ->
+ [{TP,M,F,A,Pat}|parse_trace_info(Pats)];
+parse_trace_info([CTP|Pats]) when CTP=:=ctp; CTP=:=ctpl; CTP=:=ctpg ->
+ [{CTP,'_','_','_'}|parse_trace_info(Pats)];
+parse_trace_info([{CTP,M}|Pats]) when CTP=:=ctp; CTP=:=ctpl; CTP=:=ctpg ->
+ [{CTP,M,'_','_'}|parse_trace_info(Pats)];
+parse_trace_info([{CTP,M,F}|Pats]) when CTP=:=ctp; CTP=:=ctpl; CTP=:=ctpg ->
+ [{CTP,M,F,'_'}|parse_trace_info(Pats)];
+parse_trace_info([{CTP,M,F,A}|Pats]) when CTP=:=ctp; CTP=:=ctpl; CTP=:=ctpg ->
+ [{CTP,M,F,A}|parse_trace_info(Pats)];
+parse_trace_info([]) ->
+ [];
+parse_trace_info([_other|Pats]) -> % ignore
+ parse_trace_info(Pats).
+
+handle_debug(Out,Trace,TI,initial) ->
+ handle_debug(Out,Trace,TI,0);
+handle_debug(_Out,end_of_trace,_TI,N) ->
+ N;
+handle_debug(Out,Trace,_TI,N) ->
+ print_trc(Out,Trace,N),
+ N+1.
+
+print_trc(Out,{trace_ts,P,call,{M,F,A},C,Ts},N) ->
+ io:format(Out,
+ "~w: ~s~n"
+ "Process : ~w~n"
+ "Call : ~w:~w/~w~n"
+ "Arguments : ~p~n"
+ "Caller : ~w~n~n",
+ [N,ts(Ts),P,M,F,length(A),A,C]);
+print_trc(Out,{trace_ts,P,call,{M,F,A},Ts},N) ->
+ io:format(Out,
+ "~w: ~s~n"
+ "Process : ~w~n"
+ "Call : ~w:~w/~w~n"
+ "Arguments : ~p~n~n",
+ [N,ts(Ts),P,M,F,length(A),A]);
+print_trc(Out,{trace_ts,P,return_from,{M,F,A},R,Ts},N) ->
+ io:format(Out,
+ "~w: ~s~n"
+ "Process : ~w~n"
+ "Return from : ~w:~w/~w~n"
+ "Return value : ~p~n~n",
+ [N,ts(Ts),P,M,F,A,R]);
+print_trc(Out,{drop,X},N) ->
+ io:format(Out,
+ "~w: Tracer dropped ~w messages - too busy~n~n",
+ [N,X]);
+print_trc(Out,Trace,N) ->
+ Ts = element(size(Trace),Trace),
+ io:format(Out,
+ "~w: ~s~n"
+ "Trace : ~p~n~n",
+ [N,ts(Ts),Trace]).
+ts({_, _, Micro} = Now) ->
+ {{Y,M,D},{H,Min,S}} = calendar:now_to_local_time(Now),
+ io_lib:format("~4.4.0w-~2.2.0w-~2.2.0w ~2.2.0w:~2.2.0w:~2.2.0w,~6.6.0w",
+ [Y,M,D,H,Min,S,Micro]).
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Start slave/peer nodes (initiated by test_server:start_node/5)
+%%%
+start_node(SlaveName, slave, Options, From, TI) when is_list(SlaveName) ->
+ start_node_slave(list_to_atom(SlaveName), Options, From, TI);
+start_node(SlaveName, slave, Options, From, TI) ->
+ start_node_slave(SlaveName, Options, From, TI);
+start_node(SlaveName, peer, Options, From, TI) when is_atom(SlaveName) ->
+ start_node_peer(atom_to_list(SlaveName), Options, From, TI);
+start_node(SlaveName, peer, Options, From, TI) ->
+ start_node_peer(SlaveName, Options, From, TI);
+start_node(_SlaveName, _Type, _Options, _From, _TI) ->
+ not_implemented_yet.
+
+%%
+%% Peer nodes are always started on the same host as test_server_ctrl
+%% Socket communication is used in case target and controller is
+%% not the same node (target must not know the controller node
+%% via erlang distribution)
+%%
+start_node_peer(SlaveName, OptList, From, TI) ->
+ SuppliedArgs = start_node_get_option_value(args, OptList, []),
+ Cleanup = start_node_get_option_value(cleanup, OptList, true),
+ HostStr = test_server_sup:hoststr(),
+ {ok,LSock} = gen_tcp:listen(0,[binary,
+ {reuseaddr,true},
+ {packet,2}]),
+ {ok,WaitPort} = inet:port(LSock),
+ NodeStarted = lists:concat([" -s ", ?MODULE, " node_started ",
+ HostStr, " ", WaitPort]),
+
+ % Support for erl_crash_dump files..
+ CrashFile = filename:join([TI#target_info.test_server_dir,
+ "erl_crash_dump."++cast_to_list(SlaveName)]),
+ CrashArgs = lists:concat([" -env ERL_CRASH_DUMP ",CrashFile," "]),
+ FailOnError = start_node_get_option_value(fail_on_error, OptList, true),
+ Pa = TI#target_info.test_server_dir,
+ Prog0 = start_node_get_option_value(erl, OptList, default),
+ Prog = pick_erl_program(Prog0),
+ Args =
+ case string:str(SuppliedArgs,"-setcookie") of
+ 0 -> "-setcookie " ++ TI#target_info.cookie ++ " " ++ SuppliedArgs;
+ _ -> SuppliedArgs
+ end,
+ Cmd = lists:concat([Prog,
+ " -detached ",
+ TI#target_info.naming, " ", SlaveName,
+ " -pa ", Pa,
+ NodeStarted,
+ CrashArgs,
+ " ", Args]),
+ Opts = case start_node_get_option_value(env, OptList, []) of
+ [] -> [];
+ Env -> [{env, Env}]
+ end,
+ %% peer is always started on localhost
+ %%
+ %% Bad environment can cause open port to fail. If this happens,
+ %% we ignore it and let the testcase handle the situation...
+ catch open_port({spawn, Cmd}, [stream|Opts]),
+
+ case start_node_get_option_value(wait, OptList, true) of
+ true ->
+ Ret = wait_for_node_started(LSock,60000,undefined,Cleanup,TI,self()),
+ case {Ret,FailOnError} of
+ {{{ok, Node}, Warning},_} ->
+ gen_server:reply(From,{{ok,Node},HostStr,Cmd,[],Warning});
+ {_,false} ->
+ gen_server:reply(From,{Ret, HostStr, Cmd});
+ {_,true} ->
+ gen_server:reply(From,{fail,{Ret, HostStr, Cmd}})
+ end;
+ false ->
+ Nodename = list_to_atom(SlaveName ++ "@" ++ HostStr),
+ I = "=== Not waiting for node",
+ gen_server:reply(From,{{ok, Nodename}, HostStr, Cmd, I, []}),
+ Self = self(),
+ spawn_link(
+ fun() ->
+ wait_for_node_started(LSock,60000,undefined,
+ Cleanup,TI,Self),
+ receive after infinity -> ok end
+ end),
+ ok
+ end.
+
+%%
+%% Slave nodes are started on a remote host if
+%% - the option remote is given when calling test_server:start_node/3
+%% or
+%% - the target type is vxworks, since only one erlang node
+%% can be started on each vxworks host.
+%%
+start_node_slave(SlaveName, OptList, From, TI) ->
+ SuppliedArgs = start_node_get_option_value(args, OptList, []),
+ Cleanup = start_node_get_option_value(cleanup, OptList, true),
+
+ CrashFile = filename:join([TI#target_info.test_server_dir,
+ "erl_crash_dump."++cast_to_list(SlaveName)]),
+ CrashArgs = lists:concat([" -env ERL_CRASH_DUMP ",CrashFile," "]),
+ Pa = TI#target_info.test_server_dir,
+ Args = lists:concat([" -pa ", Pa, " ", SuppliedArgs, CrashArgs]),
+
+ Prog0 = start_node_get_option_value(erl, OptList, default),
+ Prog = pick_erl_program(Prog0),
+ Ret =
+ case start_which_node(OptList) of
+ {error,Reason} -> {{error,Reason},undefined,undefined};
+ Host0 -> do_start_node_slave(Host0,SlaveName,Args,Prog,Cleanup,TI)
+ end,
+ gen_server:reply(From,Ret).
+
+
+do_start_node_slave(Host0, SlaveName, Args, Prog, Cleanup, TI) ->
+ case TI#target_info.where of
+ local ->
+ Host =
+ case Host0 of
+ local -> test_server_sup:hoststr();
+ _ -> cast_to_list(Host0)
+ end,
+ Cmd = Prog ++ " " ++ Args,
+ %% Can use slave.erl here because I'm both controller and target
+ %% so I will ping the new node anyway
+ case slave:start(Host, SlaveName, Args, no_link, Prog) of
+ {ok,Nodename} ->
+ case Cleanup of
+ true -> ets:insert(slave_tab,#slave_info{name=Nodename});
+ false -> ok
+ end,
+ {{ok,Nodename}, Host, Cmd, [], []};
+ Ret ->
+ {Ret, Host, Cmd}
+ end;
+
+ _Sock ->
+ %% Cannot use slave.erl here because I'm only controller, and will
+ %% not ping the new node. Only target shall contact the new node!!
+ no_contact_start_slave(Host0,SlaveName,Args,Prog,Cleanup,TI)
+ end.
+
+
+
+no_contact_start_slave(Host, Name, Args0, Prog, Cleanup,TI) ->
+ Args1 = case string:str(Args0,"-setcookie") of
+ 0 -> "-setcookie " ++ TI#target_info.cookie ++ " " ++ Args0;
+ _ -> Args0
+ end,
+ Args = TI#target_info.naming ++ " " ++ cast_to_list(Name) ++ " " ++ Args1,
+ case Host of
+ local ->
+ case get(test_server_free_targets) of
+ [] ->
+ io:format("Starting slave ~p on HOST~n", [Name]),
+ TargetType = test_server_sup:get_os_family(),
+ Cmd0 = get_slave_node_start_command(TargetType,
+ Prog,
+ TI#target_info.master),
+ Cmd = Cmd0 ++ " " ++ Args,
+ do_no_contact_start_slave(TargetType,
+ test_server_sup:hoststr(),
+ Cmd, Cleanup,TI, false);
+ [H|T] ->
+ TargetType = TI#target_info.os_family,
+ Cmd0 = get_slave_node_start_command(TargetType,
+ Prog,
+ TI#target_info.master),
+ Cmd = Cmd0 ++ " " ++ Args,
+ case do_no_contact_start_slave(TargetType,H,Cmd,Cleanup,
+ TI,true) of
+ {error,remove} ->
+ io:format("Cannot start node on ~p, "
+ "removing from slave "
+ "target list.", [H]),
+ put(test_server_free_targets,T),
+ no_contact_start_slave(Host,Name,Args,Prog,
+ Cleanup,TI);
+ {error,keep} ->
+ %% H is added to the END OF THE LIST
+ %% in order to avoid the same target to
+ %% be selected each time
+ put(test_server_free_targets,T++[H]),
+ no_contact_start_slave(Host,Name,Args,Prog,
+ Cleanup,TI);
+ R ->
+ put(test_server_free_targets,T),
+ R
+ end
+ end;
+ _ ->
+ TargetType = TI#target_info.os_family,
+ Cmd0 = get_slave_node_start_command(TargetType,
+ Prog,
+ TI#target_info.master),
+ Cmd = Cmd0 ++ " " ++ Args,
+ do_no_contact_start_slave(TargetType, Host, Cmd, Cleanup, TI, false)
+ end.
+
+do_no_contact_start_slave(TargetType,Host0,Cmd0,Cleanup,TI,Retry) ->
+ %% Must use TargetType instead of TI#target_info.os_familiy here
+ %% because if there were no free_targets we will be starting the
+ %% slave node on host which might have a different os_familiy
+ Host = cast_to_list(Host0),
+ {ok,LSock} = gen_tcp:listen(0,[binary,
+ {reuseaddr,true},
+ {packet,2}]),
+ {ok,WaitPort} = inet:port(LSock),
+ Cmd = lists:concat([Cmd0, " -s ", ?MODULE, " node_started ",
+ test_server_sup:hoststr(), " ", WaitPort]),
+
+ case start_target(TargetType,Host,Cmd) of
+ {ok,Client,AcceptTimeout} ->
+ case wait_for_node_started(LSock,AcceptTimeout,
+ Client,Cleanup,TI,self()) of
+ {error,_}=WaitError ->
+ if Retry ->
+ case maybe_reboot_target(Client) of
+ {error,_} -> {error,remove};
+ ok -> {error,keep}
+ end;
+ true ->
+ {WaitError,Host,Cmd}
+ end;
+ {Ok,Warning} ->
+ {Ok,Host,Cmd,[],Warning}
+ end;
+ StartError ->
+ gen_tcp:close(LSock),
+ if Retry -> {error,remove};
+ true -> {{error,{could_not_start_target,StartError}},Host,Cmd}
+ end
+ end.
+
+
+wait_for_node_started(LSock,Timeout,Client,Cleanup,TI,CtrlPid) ->
+ case gen_tcp:accept(LSock,Timeout) of
+ {ok,Sock} ->
+ gen_tcp:close(LSock),
+ receive
+ {tcp,Sock,Started0} when is_binary(Started0) ->
+ case unpack(Started0) of
+ error ->
+ gen_tcp:close(Sock),
+ {error, connection_closed};
+ {ok,Started} ->
+ Version = TI#target_info.otp_release,
+ VsnStr = TI#target_info.system_version,
+ {ok,Nodename, W} =
+ handle_start_node_return(Version,
+ VsnStr,
+ Started),
+ case Cleanup of
+ true ->
+ ets:insert(slave_tab,#slave_info{name=Nodename,
+ socket=Sock,
+ client=Client});
+ false -> ok
+ end,
+ gen_tcp:controlling_process(Sock,CtrlPid),
+ test_server_ctrl:node_started(Nodename),
+ {{ok,Nodename},W}
+ end;
+ {tcp_closed,Sock} ->
+ gen_tcp:close(Sock),
+ {error, connection_closed}
+ after Timeout ->
+ gen_tcp:close(Sock),
+ {error, timeout}
+ end;
+ {error,Reason} ->
+ gen_tcp:close(LSock),
+ {error, {no_connection,Reason}}
+ end.
+
+
+
+handle_start_node_return(Version,VsnStr,{started, Node, Version, VsnStr}) ->
+ {ok, Node, []};
+handle_start_node_return(Version,VsnStr,{started, Node, OVersion, OVsnStr}) ->
+ Str = io_lib:format("WARNING: Started node "
+ "reports different system "
+ "version than current node! "
+ "Current node version: ~p, ~p "
+ "Started node version: ~p, ~p",
+ [Version, VsnStr,
+ OVersion, OVsnStr]),
+ Str1 = lists:flatten(Str),
+ {ok, Node, Str1}.
+
+
+%%
+%% This function executes on the new node
+%%
+node_started([Host,PortAtom]) ->
+ %% Must spawn a new process because the boot process should not
+ %% hang forever!!
+ spawn(fun() -> node_started(Host,PortAtom) end).
+
+%% This process hangs forever, just waiting for the socket to be
+%% closed and terminating the node
+node_started(Host,PortAtom) ->
+ {_, Version} = init:script_id(),
+ VsnStr = erlang:system_info(system_version),
+ Port = list_to_integer(atom_to_list(PortAtom)),
+ case catch gen_tcp:connect(Host,Port, [binary,
+ {reuseaddr,true},
+ {packet,2}]) of
+
+ {ok,Sock} ->
+ Started = term_to_binary({started, node(), Version, VsnStr}),
+ ok = gen_tcp:send(Sock, [1|Started]),
+ receive _Anyting ->
+ gen_tcp:close(Sock),
+ erlang:halt()
+ end;
+ _else ->
+ erlang:halt()
+ end.
+
+
+
+
+
+% start_which_node(Optlist) -> hostname
+start_which_node(Optlist) ->
+ case start_node_get_option_value(remote, Optlist) of
+ undefined ->
+ local;
+ true ->
+ case find_remote_host() of
+ {error, Other} ->
+ {error, Other};
+ RHost ->
+ RHost
+ end
+ end.
+
+find_remote_host() ->
+ HostList=test_server_ctrl:get_hosts(),
+ case lists:delete(test_server_sup:hoststr(), HostList) of
+ [] ->
+ {error, no_remote_hosts};
+ [RHost|_Rest] ->
+ RHost
+ end.
+
+start_node_get_option_value(Key, List) ->
+ start_node_get_option_value(Key, List, undefined).
+
+start_node_get_option_value(Key, List, Default) ->
+ case lists:keysearch(Key, 1, List) of
+ {value, {Key, Value}} ->
+ Value;
+ false ->
+ Default
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% stop_node(Name) -> ok | {error,Reason}
+%%
+%% Clean up - test_server will stop this node
+stop_node(Name, TI) ->
+ case ets:lookup(slave_tab,Name) of
+ [#slave_info{client=Client}] ->
+ ets:delete(slave_tab,Name),
+ HostAtom = test_server_sup:hostatom(Name),
+ case lists:member(HostAtom,TI#target_info.slave_targets) of
+ true ->
+ put(test_server_free_targets,
+ get(test_server_free_targets) ++ [HostAtom]);
+ false -> ok
+ end,
+ close_target_client(Client),
+ ok;
+ [] ->
+ {error, not_a_slavenode}
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% kill_nodes(TI) -> ok
+%%
+%% Brutally kill all slavenodes that were not stopped by test_server
+kill_nodes(TI) ->
+ case ets:match_object(slave_tab,'_') of
+ [] -> [];
+ List ->
+ lists:map(fun(SI) -> kill_node(SI,TI) end, List)
+ end.
+
+kill_node(SI,TI) ->
+ Name = SI#slave_info.name,
+ ets:delete(slave_tab,Name),
+ HostAtom = test_server_sup:hostatom(Name),
+ case lists:member(HostAtom,TI#target_info.slave_targets) of
+ true ->
+ put(test_server_free_targets,
+ get(test_server_free_targets) ++ [HostAtom]);
+ false -> ok
+ end,
+ case SI#slave_info.socket of
+ undefined ->
+ catch rpc:call(Name,erlang,halt,[]);
+ Sock ->
+ gen_tcp:close(Sock)
+ end,
+ close_target_client(SI#slave_info.client),
+ Name.
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% Platform specific code
+
+start_target(vxworks,TargetHost,Cmd) ->
+ case vxworks_client:open(TargetHost) of
+ {ok,P} ->
+ case vxworks_client:send_data(P,Cmd,"start_erl called") of
+ {ok,_} ->
+ {ok,{vxworks,P},?VXWORKS_ACCEPT_TIMEOUT};
+ Error ->
+ Error
+ end;
+ Error ->
+ Error
+ end;
+
+start_target(unix,TargetHost,Cmd0) ->
+ Cmd =
+ case test_server_sup:hoststr() of
+ TargetHost -> Cmd0;
+ _ -> lists:concat(["rsh ",TargetHost, " ", Cmd0])
+ end,
+ open_port({spawn, Cmd}, [stream]),
+ {ok,undefined,?ACCEPT_TIMEOUT}.
+
+maybe_reboot_target({vxworks,P}) when is_pid(P) ->
+ %% Reboot the vxworks card.
+ %% Client is also closed after this, even if reboot fails
+ vxworks_client:send_data_wait_for_close(P,"q");
+maybe_reboot_target({vxworks,T}) when is_atom(T) ->
+ %% Reboot the vxworks card.
+ %% Client is also closed after this, even if reboot fails
+ vxworks_client:reboot(T);
+maybe_reboot_target(_) ->
+ {error, cannot_reboot_target}.
+
+close_target_client({vxworks,P}) ->
+ vxworks_client:close(P);
+close_target_client(undefined) ->
+ ok.
+
+
+
+%%
+%% Command for starting main target
+%%
+get_main_target_start_command(vxworks,_TargetHost,Naming,
+ _MasterNode,_MasterCookie) ->
+ "e" ++ Naming ++ " test_server -boot start_sasl"
+ " -sasl errlog_type error"
+ " -s test_server start " ++ test_server_sup:hoststr();
+get_main_target_start_command(unix,_TargetHost,Naming,
+ _MasterNode,_MasterCookie) ->
+ Prog = pick_erl_program(default),
+ Prog ++ " " ++ Naming ++ " test_server" ++
+ " -boot start_sasl -sasl errlog_type error"
+ " -s test_server start " ++ test_server_sup:hoststr().
+
+%%
+%% Command for starting slave nodes
+%%
+get_slave_node_start_command(vxworks, _Prog, _MasterNode) ->
+ "e";
+ %"e-noinput -master " ++ MasterNode;
+get_slave_node_start_command(unix, Prog, MasterNode) ->
+ cast_to_list(Prog) ++ " -detached -master " ++ MasterNode.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% cast_to_list(X) -> string()
+%%% X = list() | atom() | void()
+%%% Returns a string representation of whatever was input
+
+cast_to_list(X) when is_list(X) -> X;
+cast_to_list(X) when is_atom(X) -> atom_to_list(X);
+cast_to_list(X) -> lists:flatten(io_lib:format("~w", [X])).
+
+
+%%% L contains elements of the forms
+%%% {prog, String}
+%%% {release, Rel} where Rel = String | latest | previous
+%%% this
+%%%
+pick_erl_program(default) ->
+ cast_to_list(lib:progname());
+pick_erl_program(L) ->
+ P = random_element(L),
+ case P of
+ {prog, S} ->
+ S;
+ {release, S} ->
+ find_release(S);
+ this ->
+ lib:progname()
+ end.
+
+random_element(L) ->
+ {A,B,C} = now(),
+ E = lists:sum([A,B,C]) rem length(L),
+ lists:nth(E+1, L).
+
+find_release(latest) ->
+ "/usr/local/otp/releases/latest/bin/erl";
+find_release(previous) ->
+ "kaka";
+find_release(Rel) ->
+ find_release(os:type(), Rel).
+
+find_release({unix,sunos}, Rel) ->
+ case os:cmd("uname -p") of
+ "sparc" ++ _ ->
+ "/usr/local/otp/releases/otp_beam_solaris8_" ++ Rel ++ "/bin/erl";
+ _ ->
+ none
+ end;
+find_release({unix,linux}, Rel) ->
+ Candidates = find_rel_linux(Rel),
+ case lists:dropwhile(fun(N) ->
+ not filelib:is_regular(N)
+ end, Candidates) of
+ [] -> none;
+ [Erl|_] -> Erl
+ end;
+find_release(_, _) -> none.
+
+find_rel_linux(Rel) ->
+ case suse_release() of
+ none -> [];
+ SuseRel -> find_rel_suse(Rel, SuseRel)
+ end.
+
+find_rel_suse(Rel, SuseRel) ->
+ Root = "/usr/local/otp/releases/otp_beam_linux_sles",
+ case SuseRel of
+ "11" ->
+ %% Try both SuSE 11, SuSE 10 and SuSe 9 in that order.
+ find_rel_suse_1(Rel, Root++"11") ++
+ find_rel_suse_1(Rel, Root++"10") ++
+ find_rel_suse_1(Rel, Root++"9");
+ "10" ->
+ %% Try both SuSE 10 and SuSe 9 in that order.
+ find_rel_suse_1(Rel, Root++"10") ++
+ find_rel_suse_1(Rel, Root++"9");
+ "9" ->
+ find_rel_suse_1(Rel, Root++"9");
+ _ ->
+ []
+ end.
+
+find_rel_suse_1(Rel, RootWc) ->
+ case erlang:system_info(wordsize) of
+ 4 ->
+ find_rel_suse_2(Rel, RootWc++"_i386");
+ 8 ->
+ find_rel_suse_2(Rel, RootWc++"_x64") ++
+ find_rel_suse_2(Rel, RootWc++"_i386")
+ end.
+
+find_rel_suse_2(Rel, RootWc) ->
+ Wc = RootWc ++ "_" ++ Rel,
+ case filelib:wildcard(Wc) of
+ [] ->
+ [];
+ [R|_] ->
+ [filename:join([R,"bin","erl"])]
+ end.
+
+%% suse_release() -> VersionString | none.
+%% Return the major SuSE version number for this platform or
+%% 'none' if this is not a SuSE platform.
+suse_release() ->
+ case file:open("/etc/SuSE-release", [read]) of
+ {ok,Fd} ->
+ try
+ suse_release(Fd)
+ after
+ file:close(Fd)
+ end;
+ {error,_} -> none
+ end.
+
+suse_release(Fd) ->
+ case io:get_line(Fd, '') of
+ eof -> none;
+ Line when is_list(Line) ->
+ case re:run(Line, "^VERSION\\s*=\\s*(\\d+)\s*",
+ [{capture,all_but_first,list}]) of
+ nomatch ->
+ suse_release(Fd);
+ {match,[Version]} ->
+ Version
+ end
+ end.
+
+unpack(Bin) ->
+ {One,Term} = split_binary(Bin, 1),
+ case binary_to_list(One) of
+ [1] ->
+ case catch {ok,binary_to_term(Term)} of
+ {'EXIT',_} -> error;
+ {ok,_}=Res -> Res
+ end;
+ _ -> error
+ end.
+
+id(I) -> I.
+
+print_data(Port) ->
+ receive
+ {Port, {data, Bytes}} ->
+ io:put_chars(Bytes),
+ print_data(Port);
+ {Port, eof} ->
+ Port ! {self(), close},
+ receive
+ {Port, closed} ->
+ true
+ end,
+ receive
+ {'EXIT', Port, _} ->
+ ok
+ after 1 -> % force context switch
+ ok
+ end
+ end.
diff --git a/lib/test_server/src/test_server_sup.erl b/lib/test_server/src/test_server_sup.erl
new file mode 100644
index 0000000000..c665f185fd
--- /dev/null
+++ b/lib/test_server/src/test_server_sup.erl
@@ -0,0 +1,616 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1998-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%%-------------------------------------------------------------------
+%%% Purpose: Test server support functions.
+%%%-------------------------------------------------------------------
+-module(test_server_sup).
+-export([timetrap/2, timetrap_cancel/1, capture_get/1, messages_get/1,
+ timecall/3, call_crash/5, app_test/2, check_new_crash_dumps/0,
+ cleanup_crash_dumps/0, crash_dump_dir/0, tar_crash_dumps/0,
+ get_username/0, get_os_family/0,
+ hostatom/0, hostatom/1, hoststr/0, hoststr/1,
+ framework_call/2,framework_call/3,
+ format_loc/1, package_str/1, package_atom/1,
+ call_trace/1]).
+-include("test_server_internal.hrl").
+-define(crash_dump_tar,"crash_dumps.tar.gz").
+-define(src_listing_ext, ".src.html").
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timetrap(Timeout,Pid) -> Handle
+%% Handle = term()
+%%
+%% Creates a time trap, that will kill the given process if the
+%% trap is not cancelled with timetrap_cancel/1, within Timeout
+%% milliseconds.
+
+timetrap(Timeout0, Pid) ->
+ process_flag(priority, max),
+ Timeout = test_server:timetrap_scale_factor() * Timeout0,
+ receive
+ after trunc(Timeout) ->
+ Line = test_server:get_loc(Pid),
+ Mon = erlang:monitor(process, Pid),
+ Trap =
+ case get(test_server_init_or_end_conf) of
+ undefined ->
+ {timetrap_timeout,trunc(Timeout),Line};
+ InitOrEnd ->
+ {timetrap_timeout,trunc(Timeout),Line,InitOrEnd}
+ end,
+ exit(Pid,Trap),
+ receive
+ {'DOWN', Mon, process, Pid, _} ->
+ ok
+ after 10000 ->
+ %% Pid is probably trapping exits, hit it harder...
+ catch error_logger:warning_msg("Testcase process ~p not "
+ "responding to timetrap "
+ "timeout:~n"
+ " ~p.~n"
+ "Killing testcase...~n",
+ [Pid, Trap]),
+ exit(Pid, kill)
+ end
+ end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% timetrap_cancel(Handle) -> ok
+%% Handle = term()
+%%
+%% Cancels a time trap.
+
+timetrap_cancel(Handle) ->
+ unlink(Handle),
+ MonRef = erlang:monitor(process, Handle),
+ exit(Handle, kill),
+ receive {'DOWN',MonRef,_,_,_} -> ok after 2000 -> ok end.
+
+capture_get(Msgs) ->
+ receive
+ {captured,Msg} ->
+ capture_get([Msg|Msgs])
+ after 0 ->
+ lists:reverse(Msgs)
+ end.
+
+
+messages_get(Msgs) ->
+ receive
+ Msg ->
+ messages_get([Msg|Msgs])
+ after 0 ->
+ lists:reverse(Msgs)
+ end.
+
+
+timecall(M, F, A) ->
+ Befor = erlang:now(),
+ Val = apply(M, F, A),
+ After = erlang:now(),
+ Elapsed =
+ (element(1,After)*1000000+element(2,After)+element(3,After)/1000000)-
+ (element(1,Befor)*1000000+element(2,Befor)+element(3,Befor)/1000000),
+ {Elapsed, Val}.
+
+
+
+call_crash(Time,Crash,M,F,A) ->
+ OldTrapExit = process_flag(trap_exit,true),
+ Pid = spawn_link(M,F,A),
+ Answer =
+ receive
+ {'EXIT',Crash} ->
+ ok;
+ {'EXIT',Pid,Crash} ->
+ ok;
+ {'EXIT',_Reason} when Crash==any ->
+ ok;
+ {'EXIT',Pid,_Reason} when Crash==any ->
+ ok;
+ {'EXIT',Reason} ->
+ test_server:format(12, "Wrong crash reason. Wanted ~p, got ~p.",
+ [Crash, Reason]),
+ exit({wrong_crash_reason,Reason});
+ {'EXIT',Pid,Reason} ->
+ test_server:format(12, "Wrong crash reason. Wanted ~p, got ~p.",
+ [Crash, Reason]),
+ exit({wrong_crash_reason,Reason});
+ {'EXIT',OtherPid,Reason} when OldTrapExit == false ->
+ exit({'EXIT',OtherPid,Reason})
+ after do_trunc(Time) ->
+ exit(call_crash_timeout)
+ end,
+ process_flag(trap_exit,OldTrapExit),
+ Answer.
+
+do_trunc(infinity) -> infinity;
+do_trunc(T) -> trunc(T).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% app_test/2
+%%
+%% Checks one applications .app file for obvious errors.
+%% Checks..
+%% * .. required fields
+%% * .. that all modules specified actually exists
+%% * .. that all requires applications exists
+%% * .. that no module included in the application has export_all
+%% * .. that all modules in the ebin/ dir is included
+%% (This only produce a warning, as all modules does not
+%% have to be included (If the `pedantic' option isn't used))
+app_test(Application, Mode) ->
+ case is_app(Application) of
+ {ok, AppFile} ->
+ do_app_tests(AppFile, Application, Mode);
+ Error ->
+ test_server:fail(Error)
+ end.
+
+is_app(Application) ->
+ case file:consult(filename:join([code:lib_dir(Application),"ebin",
+ atom_to_list(Application)++".app"])) of
+ {ok, [{application, Application, AppFile}] } ->
+ {ok, AppFile};
+ _ ->
+ test_server:format(minor,
+ "Application (.app) file not found, "
+ "or it has very bad syntax.~n"),
+ {error, not_an_application}
+ end.
+
+
+do_app_tests(AppFile, AppName, Mode) ->
+ DictList=
+ [
+ {missing_fields, []},
+ {missing_mods, []},
+ {superfluous_mods_in_ebin, []},
+ {export_all_mods, []},
+ {missing_apps, []}
+ ],
+ fill_dictionary(DictList),
+
+ %% An appfile must (?) have some fields..
+ check_fields([description, modules, registered, applications], AppFile),
+
+ %% Check for missing and extra modules.
+ {value, {modules, Mods}}=lists:keysearch(modules, 1, AppFile),
+ EBinList=lists:sort(get_ebin_modnames(AppName)),
+ {Missing, Extra} = common(lists:sort(Mods), EBinList),
+ put(superfluous_mods_in_ebin, Extra),
+ put(missing_mods, Missing),
+
+ %% Check that no modules in the application has export_all.
+ app_check_export_all(Mods),
+
+ %% Check that all specified applications exists.
+ {value, {applications, Apps}}=
+ lists:keysearch(applications, 1, AppFile),
+ check_apps(Apps),
+
+ A=check_dict(missing_fields, "Inconsistent app file, "
+ "missing fields"),
+ B=check_dict(missing_mods, "Inconsistent app file, "
+ "missing modules"),
+ C=check_dict_tolerant(superfluous_mods_in_ebin, "Inconsistent app file, "
+ "Modules not included in app file.", Mode),
+ D=check_dict(export_all_mods, "Inconsistent app file, "
+ "Modules have `export_all'."),
+ E=check_dict(missing_apps, "Inconsistent app file, "
+ "missing applications."),
+
+ erase_dictionary(DictList),
+ case A+B+C+D+E of
+ 5 ->
+ ok;
+ _ ->
+ test_server:fail()
+ end.
+
+app_check_export_all([]) ->
+ ok;
+app_check_export_all([Mod|Mods]) ->
+ case catch apply(Mod, module_info, [compile]) of
+ {'EXIT', {undef,_}} ->
+ app_check_export_all(Mods);
+ COpts ->
+ case lists:keysearch(options, 1, COpts) of
+ false ->
+ app_check_export_all(Mods);
+ {value, {options, List}} ->
+ case lists:member(export_all, List) of
+ true ->
+ put(export_all_mods, [Mod|get(export_all_mods)]),
+ app_check_export_all(Mods);
+ false ->
+ app_check_export_all(Mods)
+ end
+ end
+ end.
+
+%% Given two sorted lists, L1 and L2, returns {NotInL2, NotInL1},
+%% NotInL2 is the elements of L1 which don't occurr in L2,
+%% NotInL1 is the elements of L2 which don't ocurr in L1.
+
+common(L1, L2) ->
+ common(L1, L2, [], []).
+
+common([X|Rest1], [X|Rest2], A1, A2) ->
+ common(Rest1, Rest2, A1, A2);
+common([X|Rest1], [Y|Rest2], A1, A2) when X < Y ->
+ common(Rest1, [Y|Rest2], [X|A1], A2);
+common([X|Rest1], [Y|Rest2], A1, A2) ->
+ common([X|Rest1], Rest2, A1, [Y|A2]);
+common([], L, A1, A2) ->
+ {A1, L++A2};
+common(L, [], A1, A2) ->
+ {L++A1, A2}.
+
+check_apps([]) ->
+ ok;
+check_apps([App|Apps]) ->
+ case is_app(App) of
+ {ok, _AppFile} ->
+ ok;
+ {error, _} ->
+ put(missing_apps, [App|get(missing_apps)])
+ end,
+ check_apps(Apps).
+
+check_fields([], _AppFile) ->
+ ok;
+check_fields([L|Ls], AppFile) ->
+ check_field(L, AppFile),
+ check_fields(Ls, AppFile).
+
+check_field(FieldName, AppFile) ->
+ case lists:keymember(FieldName, 1, AppFile) of
+ true ->
+ ok;
+ false ->
+ put(missing_fields, [FieldName|get(missing_fields)]),
+ ok
+ end.
+
+check_dict(Dict, Reason) ->
+ case get(Dict) of
+ [] ->
+ 1; % All ok.
+ List ->
+ io:format("** ~s (~s) ->~n~p~n",[Reason, Dict, List]),
+ 0
+ end.
+
+check_dict_tolerant(Dict, Reason, Mode) ->
+ case get(Dict) of
+ [] ->
+ 1; % All ok.
+ List ->
+ io:format("** ~s (~s) ->~n~p~n",[Reason, Dict, List]),
+ case Mode of
+ pedantic ->
+ 0;
+ _ ->
+ 1
+ end
+ end.
+
+get_ebin_modnames(AppName) ->
+ Wc=filename:join([code:lib_dir(AppName),"ebin",
+ "*"++code:objfile_extension()]),
+ TheFun=fun(X, Acc) ->
+ [list_to_atom(filename:rootname(
+ filename:basename(X)))|Acc] end,
+ _Files=lists:foldl(TheFun, [], filelib:wildcard(Wc)).
+
+%%
+%% This function removes any erl_crash_dump* files found in the
+%% test server directory. Done only once when the test server
+%% is started.
+%%
+cleanup_crash_dumps() ->
+ Dir = crash_dump_dir(),
+ Dumps = filelib:wildcard(filename:join(Dir, "erl_crash_dump*")),
+ delete_files(Dumps).
+
+crash_dump_dir() ->
+ filename:dirname(code:which(?MODULE)).
+
+tar_crash_dumps() ->
+ Dir = crash_dump_dir(),
+ case filelib:wildcard(filename:join(Dir, "erl_crash_dump*")) of
+ [] -> {error,no_crash_dumps};
+ Dumps ->
+ TarFileName = filename:join(Dir,?crash_dump_tar),
+ {ok,Tar} = erl_tar:open(TarFileName,[write,compressed]),
+ lists:foreach(
+ fun(File) ->
+ ok = erl_tar:add(Tar,File,filename:basename(File),[])
+ end,
+ Dumps),
+ ok = erl_tar:close(Tar),
+ delete_files(Dumps),
+ {ok,TarFileName}
+ end.
+
+
+check_new_crash_dumps() ->
+ Dir = crash_dump_dir(),
+ Dumps = filelib:wildcard(filename:join(Dir, "erl_crash_dump*")),
+ case length(Dumps) of
+ 0 ->
+ ok;
+ Num ->
+ test_server_ctrl:format(minor,
+ "Found ~p crash dumps:~n", [Num]),
+ append_files_to_logfile(Dumps),
+ delete_files(Dumps)
+ end.
+
+append_files_to_logfile([]) -> ok;
+append_files_to_logfile([File|Files]) ->
+ NodeName=from($., File),
+ test_server_ctrl:format(minor, "Crash dump from node ~p:~n",[NodeName]),
+ Fd=get(test_server_minor_fd),
+ case file:read_file(File) of
+ {ok, Bin} ->
+ case file:write(Fd, Bin) of
+ ok ->
+ ok;
+ {error,Error} ->
+ %% Write failed. The following io:format/3 will probably also
+ %% fail, but in that case it will throw an exception so that
+ %% we will be aware of the problem.
+ io:format(Fd, "Unable to write the crash dump "
+ "to this file: ~p~n", [file:format_error(Error)])
+ end;
+ _Error ->
+ io:format(Fd, "Failed to read: ~s\n", [File])
+ end,
+ append_files_to_logfile(Files).
+
+delete_files([]) -> ok;
+delete_files([File|Files]) ->
+ io:format("Deleting file: ~s~n", [File]),
+ case file:delete(File) of
+ {error, _} ->
+ case file:rename(File, File++".old") of
+ {error, Error} ->
+ io:format("Could neither delete nor rename file "
+ "~s: ~s.~n", [File, Error]);
+ _ ->
+ ok
+ end;
+ _ ->
+ ok
+ end,
+ delete_files(Files).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% erase_dictionary(Vars) -> ok
+%% Vars = [atom(),...]
+%%
+%% Takes a list of dictionary keys, KeyVals, erases
+%% each key and returns ok.
+erase_dictionary([{Var, _Val}|Vars]) ->
+ erase(Var),
+ erase_dictionary(Vars);
+erase_dictionary([]) ->
+ ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% fill_dictionary(KeyVals) -> void()
+%% KeyVals = [{atom(),term()},...]
+%%
+%% Takes each Key-Value pair, and inserts it in the process dictionary.
+fill_dictionary([{Var,Val}|Vars]) ->
+ put(Var,Val),
+ fill_dictionary(Vars);
+fill_dictionary([]) ->
+ [].
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% get_username() -> UserName
+%%
+%% Returns the current user
+get_username() ->
+ getenv_any(["USER","USERNAME"]).
+
+getenv_any([Key|Rest]) ->
+ case catch os:getenv(Key) of
+ String when is_list(String) -> String;
+ false -> getenv_any(Rest)
+ end;
+getenv_any([]) -> "".
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% get_os_family() -> OsFamily
+%%
+%% Returns the OS family
+get_os_family() ->
+ case os:type() of
+ {OsFamily,_OsName} -> OsFamily;
+ OsFamily -> OsFamily
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% hostatom()/hostatom(Node) -> Host; atom()
+%% hoststr() | hoststr(Node) -> Host; string()
+%%
+%% Returns the OS family
+hostatom() ->
+ hostatom(node()).
+hostatom(Node) ->
+ list_to_atom(hoststr(Node)).
+hoststr() ->
+ hoststr(node()).
+hoststr(Node) when is_atom(Node) ->
+ hoststr(atom_to_list(Node));
+hoststr(Node) when is_list(Node) ->
+ from($@, Node).
+
+from(H, [H | T]) -> T;
+from(H, [_ | T]) -> from(H, T);
+from(_H, []) -> [].
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% framework_call(Callback,Func,Args,DefaultReturn) -> Return | DefaultReturn
+%%
+%% Calls the given Func in Callback
+framework_call(Func,Args) ->
+ framework_call(Func,Args,ok).
+framework_call(Func,Args,DefaultReturn) ->
+ CB = os:getenv("TEST_SERVER_FRAMEWORK"),
+ framework_call(CB,Func,Args,DefaultReturn).
+framework_call(false,_Func,_Args,DefaultReturn) ->
+ DefaultReturn;
+framework_call(Callback,Func,Args,DefaultReturn) ->
+ Mod = list_to_atom(Callback),
+ case code:is_loaded(Mod) of
+ false -> code:load_file(Mod);
+ _ -> ok
+ end,
+ case erlang:function_exported(Mod,Func,length(Args)) of
+ true ->
+ apply(Mod,Func,Args);
+ false ->
+ DefaultReturn
+ end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% format_loc(Loc) -> string()
+%%
+%% Formats the printout of the line of code read from
+%% process dictionary (test_server_loc). Adds link to
+%% correct line in source code.
+format_loc([{Mod,Func,Line}]) ->
+ [format_loc1({Mod,Func,Line})];
+format_loc([{Mod,Func,Line}|Rest]) ->
+ ["[",format_loc1({Mod,Func,Line}),",\n"|format_loc1(Rest)];
+format_loc([{Mod,LineOrFunc}]) ->
+ format_loc({Mod,LineOrFunc});
+format_loc({Mod,Func}) when is_atom(Func) ->
+ io_lib:format("{~s,~w}",[package_str(Mod),Func]);
+format_loc({Mod,Line}) when is_integer(Line) ->
+ %% ?line macro is used
+ ModStr = package_str(Mod),
+ case lists:reverse(ModStr) of
+ [$E,$T,$I,$U,$S,$_|_] ->
+ io_lib:format("{~s,<a href=\"~s~s#~w\">~w</a>}",
+ [ModStr,downcase(ModStr),?src_listing_ext,
+ round_to_10(Line),Line]);
+ _ ->
+ io_lib:format("{~s,~w}",[ModStr,Line])
+ end;
+format_loc(Loc) ->
+ io_lib:format("~p",[Loc]).
+
+format_loc1([{Mod,Func,Line}]) ->
+ [" ",format_loc1({Mod,Func,Line}),"]"];
+format_loc1([{Mod,Func,Line}|Rest]) ->
+ [" ",format_loc1({Mod,Func,Line}),",\n"|format_loc1(Rest)];
+format_loc1({Mod,Func,Line}) ->
+ ModStr = package_str(Mod),
+ case lists:reverse(ModStr) of
+ [$E,$T,$I,$U,$S,$_|_] ->
+ io_lib:format("{~s,~w,<a href=\"~s~s#~w\">~w</a>}",
+ [ModStr,Func,downcase(ModStr),?src_listing_ext,
+ round_to_10(Line),Line]);
+ _ ->
+ io_lib:format("{~s,~w,~w}",[ModStr,Func,Line])
+ end.
+
+round_to_10(N) when (N rem 10) == 0 ->
+ N;
+round_to_10(N) ->
+ trunc(N/10)*10.
+
+downcase(S) -> downcase(S, []).
+downcase([Uc|Rest], Result) when $A =< Uc, Uc =< $Z ->
+ downcase(Rest, [Uc-$A+$a|Result]);
+downcase([C|Rest], Result) ->
+ downcase(Rest, [C|Result]);
+downcase([], Result) ->
+ lists:reverse(Result).
+
+package_str(Mod) when is_atom(Mod) ->
+ atom_to_list(Mod);
+package_str(Mod) when is_list(Mod), is_atom(hd(Mod)) ->
+ %% convert [s1,s2] -> "s1.s2"
+ [_|M] = lists:flatten(["."++atom_to_list(S) || S <- Mod]),
+ M;
+package_str(Mod) when is_list(Mod) ->
+ Mod.
+
+package_atom(Mod) when is_atom(Mod) ->
+ Mod;
+package_atom(Mod) when is_list(Mod), is_atom(hd(Mod)) ->
+ list_to_atom(package_str(Mod));
+package_atom(Mod) when is_list(Mod) ->
+ list_to_atom(Mod).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% call_trace(TraceSpecFile) -> ok
+%%
+%% Read terms on format {m,Mod} | {f,Mod,Func}
+%% from TraceSpecFile and enable call trace for
+%% specified functions.
+call_trace(TraceSpec) ->
+ case catch try_call_trace(TraceSpec) of
+ {'EXIT',Reason} ->
+ erlang:display(Reason),
+ exit(Reason);
+ Ok ->
+ Ok
+ end.
+
+try_call_trace(TraceSpec) ->
+ case file:consult(TraceSpec) of
+ {ok,Terms} ->
+ dbg:tracer(),
+ %% dbg:p(self(), [p, m, sos, call]),
+ dbg:p(self(), [sos, call]),
+ lists:foreach(fun({m,M}) ->
+ case dbg:tpl(M,[{'_',[],[{return_trace}]}]) of
+ {error,What} -> exit({error,{tracing_failed,What}});
+ _ -> ok
+ end;
+ ({f,M,F}) ->
+ case dbg:tpl(M,F,[{'_',[],[{return_trace}]}]) of
+ {error,What} -> exit({error,{tracing_failed,What}});
+ _ -> ok
+ end;
+ (Huh) ->
+ exit({error,{unrecognized_trace_term,Huh}})
+ end, Terms),
+ ok;
+ {_,Error} ->
+ exit({error,{tracing_failed,TraceSpec,Error}})
+ end.
+
diff --git a/lib/test_server/src/things/distr_startup_SUITE.erl b/lib/test_server/src/things/distr_startup_SUITE.erl
new file mode 100644
index 0000000000..0d4e467570
--- /dev/null
+++ b/lib/test_server/src/things/distr_startup_SUITE.erl
@@ -0,0 +1,238 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(distr_startup_SUITE).
+-compile([export_all]).
+%%-define(line_trace,1).
+-include("test_server.hrl").
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+all(suite) -> [reads,writes].
+
+-define(iterations,10000).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+app1() ->
+ {application, app1,
+ [{description, "ERTS CXC 138 10"},
+ {vsn, "2.0"},
+ {applications, [kernel, stdlib]},
+ {mod, {ch_sup, {app1, 1, 3}}}]}.
+
+app3() ->
+ {application, app3,
+ [{description, "ERTS CXC 138 10"},
+ {vsn, "2.0"},
+ {applications, [kernel, stdlib]},
+ {mod, {ch_sup, {app3, 7, 9}}}]}.
+
+
+config(Fd,C1,C2,C3) ->
+ io:format(Fd,
+ "[{kernel, [{sync_nodes_optional, ['~s','~s','~s']},"
+ "{sync_nodes_timeout, 1},"
+ "{distributed, [{app1, ['~s', '~s', '~s']},"
+ "{app2, 10000, ['~s', '~s', '~s']},"
+ "{app3, 5000, [{'~s', '~s'}, '~s']}]}]}].~n",
+ [C1,C2,C3, C1,C2,C3, C1,C2,C3, C1,C2,C3]).
+
+from(H, [H | T]) -> T;
+from(H, [_ | T]) -> from(H, T);
+from(H, []) -> [].
+
+%%-----------------------------------------------------------------
+%% Test suite for distributed applications, tests start, load
+%% etc indirectly.
+%% Should be started in a CC view with:
+%% erl -sname master -rsh ctrsh
+%%-----------------------------------------------------------------
+start_nodes(Conf) ->
+ % Write a config file
+ ?line Nodes = ?config(nodes,Conf),
+ ?line [C1,C2,C3|_] = Nodes, %% Need at least 3 nodes
+ ?line Dir = ?config(priv_dir,Conf),
+ ?line {ok, Fd} = file:open(Dir ++ "sys.config", write),
+ ?line config(Fd,C1,C2,C3),
+ ?line file:close(Fd),
+ ?line Config = Dir ++ "sys",
+
+ % Test [cp1, cp2, cp3]
+ ?line {ok, Cp1} = start_node(lists:nth(1,Nodes), Config),
+ ?line {ok, Cp2} = start_node(lists:nth(2,Nodes), Config),
+ ?line {ok, Cp3} = start_node(lists:nth(3,Nodes), Config),
+ % Start app1 and make sure cp1 starts it
+ %%?line rpc:multicall([Cp1, Cp2, Cp3], application, load, [app1()]),
+ %%?line rpc:multicall([Cp1, Cp2, Cp3], application, start,[app1,permanent]),
+ ?line test_server:sleep(1000),
+ {Cp1,Cp2,Cp3}.
+
+stop_nodes({Cp1,Cp2,Cp3}) ->
+ ?line stop_node(Cp1),
+ ?line stop_node(Cp2),
+ ?line stop_node(Cp3).
+
+start_node(NodeAtHost, Config) ->
+ ?line NodeAtHostStr = atom_to_list(NodeAtHost),
+ ?line HostStr = from($@,NodeAtHostStr),
+ ?line NodeStr = lists:reverse(from($@,lists:reverse(NodeAtHostStr))),
+ ?line Host = list_to_atom(HostStr),
+ ?line Node = list_to_atom(NodeStr),
+ ?line io:format("Launching slave node ~p@~p ~p",[Node,Host,Config]),
+ ?line slave:start(Host, Node, lists:concat(["-config ", Config])).
+
+stop_node(Node) ->
+ ?line rpc:cast(Node, erlang, halt, []).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+start_client_process(Cp,Mode,NodeNum) ->
+ io:format("Starting client process at ~p in mode ~p",[Cp,Mode]),
+ ?line case rpc:call(Cp, erlang, spawn,
+ [?MODULE, client,
+ [Mode,NodeNum,self(),random:uniform(1000)]]) of
+ {badrpc,Reason} ->
+ ?line exit({badrpc,{Cp,Reason}});
+ Client ->
+ ?line Client
+ end.
+
+start_clients(Mode,Conf) ->
+ ?line random:seed(4711,0,0),
+ ?line {Cp1,Cp2,Cp3} = start_nodes(Conf),
+ ?line Client1 = start_client_process(Cp1,Mode,1),
+ ?line Client2 = start_client_process(Cp2,Mode,2),
+ ?line Client3 = start_client_process(Cp3,Mode,3),
+ test_server:format(1,"All 3 nodes started, "
+ "power off client(s) any time...",[]),
+ Client1 ! go,
+ Client2 ! go,
+ Client3 ! go,
+ {{Cp1,Cp2,Cp3},{Client1,Client2,Client3}}.
+
+stop_clients(Cps) ->
+ test_server:format(1,"Test completed.",[]),
+ ?line stop_nodes(Cps).
+
+data() ->
+ {{self(),foo,bar,[1,2,3,4,5,6,7],{{{{}}}},
+ "We need pretty long packages, so that there is a big risk "
+ "of cutting it in the middle when suddenly turning off "
+ "the power or breaking the connection. "
+ "We don't check the contents of the data very much, but "
+ "at least there is a magic cookie at the end (123456)."
+ "If that one arrives correctly, the link is ok as far "
+ "as we are concerned."},
+ 123456}.
+
+reads(suite) -> [];
+reads(Conf) ->
+ ?line {Cps,_} = start_clients(w,Conf),
+ ?line read_loop(?iterations,0),
+ ?line stop_clients(Cps),
+ ok.
+
+read_loop(0,M) ->
+ ok;
+read_loop(N,M) ->
+ ?line Dog = test_server:timetrap(test_server:seconds(0.5)),
+ M2 =
+ receive
+ {Node,Count,{_,123456}} ->
+ ?line setelement(Node,M,element(Node,M)+1);
+ {Node,Count,Data} ->
+ ?line exit({network_transmission_error,Data});
+ {nodedown,Node} ->
+ ?line test_server:format(1,"Node ~s went down",[Node]),
+ ?line M;
+ Other ->
+ ?line M
+ after test_server:seconds(0.1) ->
+ ?line io:format("No message!"),
+ ?line M
+ end,
+ ?line test_server:timetrap_cancel(Dog),
+ ?line M3 =
+ case N rem 100 of
+ 0 -> io:format("~p reads to go (~w msgs)",[N,M2]),
+ {0,0,0};
+ _ -> M2
+ end,
+ ?line read_loop(N-1,M3).
+
+client(w,NodeNum,Pid,Seed) ->
+ random:seed(Seed,0,0),
+ receive
+ go -> ok
+ end,
+ client_write_loop(Pid,0,NodeNum,data());
+client(r,NodeNum,Pid,Seed) ->
+ random:seed(Seed,0,0),
+ receive
+ go -> ok
+ end,
+ client_read_loop(0).
+
+client_write_loop(Pid,N,NodeNum,Data) ->
+ test_server:sleep(random:uniform(20)),
+ Pid ! {NodeNum,N,Data},
+ client_write_loop(Pid,N+1,NodeNum,Data).
+
+writes(suite) -> [];
+writes(Conf) ->
+ ?line {Cps,{C1,C2,C3}} = start_clients(r,Conf),
+ ?line write_loop(2*?iterations,{C1,C2,C3},data()),
+ ?line stop_clients(Cps),
+ ok.
+
+write_loop(0,_,_) ->
+ ok;
+write_loop(N,Clients,Data) ->
+ ?line Dog = test_server:timetrap(test_server:seconds(0.5)),
+ ?line Client = element(random:uniform(size(Clients)),Clients),
+ ?line Client ! {node(),N,Data},
+ ?line test_server:timetrap_cancel(Dog),
+ receive
+ {nodedown,Node} ->
+ ?line test_server:format(1,"Node ~s went down",[Node])
+ after 0 ->
+ ?line ok
+ end,
+ ?line case N rem 100 of
+ 0 -> io:format("~p writes to go",[N]);
+ _ -> ok
+ end,
+ ?line write_loop(N-1,Clients,Data).
+
+client_read_loop(N) ->
+ receive
+ {Node,Count,{_,123456}} ->
+ ?line ok;
+ {Node,Count,Data} ->
+ ?line io:format("~p(~p): transmission error from node ~p(~p): ~p",
+ [node(),N,Node,Count,Data]);
+ Other ->
+ ?line io:format("~p(~p): got a strange message: ~p",
+ [node(),N,Other])
+ end,
+ client_read_loop(N+1).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
diff --git a/lib/test_server/src/things/mnesia_power_SUITE.erl b/lib/test_server/src/things/mnesia_power_SUITE.erl
new file mode 100644
index 0000000000..281dac7742
--- /dev/null
+++ b/lib/test_server/src/things/mnesia_power_SUITE.erl
@@ -0,0 +1,125 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(mnesia_power_SUITE).
+-compile([export_all]).
+%%-define(line_trace,1).
+-include("test_server.hrl").
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+all(suite) -> [run].
+
+-define(iterations,3). %% nof power-off cycles to do before acceptance
+-define(rows,8). %% nof database rows to use (not too big, please)
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-record(sum_table_1,{row,a,b,c,s}).
+
+run(suite) -> [];
+run(Config) ->
+ ?line mnesia:create_schema([node()]),
+ ?line mnesia:start(),
+ ?line mnesia:create_table([{name, sum_table_1}, {disc_copies,[node()]},
+ {attributes,record_info(fields,sum_table_1)}]),
+ ?line run_test(Config,?iterations).
+
+run(Config,N) ->
+ ?line mnesia:start(),
+ ?line check_consistency(sum_table_1),
+ case N of
+ 0 -> ?line ok;
+ N -> ?line run_test(Config,N)
+ end.
+
+run_test(Config,N) ->
+ ?line Pid1a = start_manipulator(sum_table_1),
+ ?line Pid1b = start_manipulator(sum_table_1),
+ ?line Pid1c = start_manipulator(sum_table_1),
+ ?line test_server:resume_point(?MODULE,run,[Config,N-1]),
+ ?line test_server:format(1,"Manipulating data like crazy now, "
+ "power off any time..."),
+ ?line test_server:sleep(infinity).
+
+start_manipulator(Table) ->
+ ?line spawn_link(?MODULE,manipulator_init,[Table]).
+
+manipulator_init(Table) ->
+ random:seed(4711,0,0),
+ manipulator(0,Table).
+
+manipulator(N,Table) ->
+ ?line Fun =
+ fun() ->
+ ?line Row = random:uniform(?rows),
+ ?line A = random:uniform(100000),
+ ?line B = random:uniform(100000),
+ ?line C = random:uniform(100000),
+ ?line Sum = A+B+C,
+ ?line case mnesia:write(#sum_table_1
+ {row=Row,a=A,b=B,c=C,s=Sum}) of
+ ok -> ok;
+ Other ->
+ ?line io:format("Trans failed: ~p\n",[Other])
+ end
+ end,
+ ?line mnesia:transaction(Fun),
+ case mnesia:table_info(sum_table_1,size) of
+ 0 -> exit(still_empty);
+ _ -> ok
+ end,
+ case N rem 2000 of
+ 0 -> io:format("~p did ~p operations",[self(),N]),
+ check_consistency(sum_table_1);
+ _ -> ok
+ end,
+ ?line manipulator(N+1,Table).
+
+check_consistency(Table) ->
+ io:format("Checking consistency of table ~p\n",[Table]),
+ All = mnesia:table_info(Table,wild_pattern),
+ ?line Fun =
+ fun() ->
+ mnesia:match_object(All)
+ end,
+ ?line case mnesia:transaction(Fun) of
+ {atomic,Val} ->
+ check_consistency_rows(Val,0);
+ Other ->
+ io:format("Trans failed: ~p\n",[Other]),
+ exit(failed),
+ check_consistency(Table)
+ end.
+
+check_consistency_rows([#sum_table_1{a=A,b=B,c=C,s=Sum}|Rows],N) ->
+ ?line Sum=A+B+C,
+ ?line check_consistency_rows(Rows,N+1);
+check_consistency_rows([],N) ->
+ io:format("All ~p rows were consistent\n",[N]),
+ {ok,N};
+check_consistency_rows(Thing,N) ->
+ io:format("Mnesia transaction returned:\n~p\n",[Thing]),
+ exit({bad_format,Thing}).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+
+
+
diff --git a/lib/test_server/src/things/random_kill_SUITE.erl b/lib/test_server/src/things/random_kill_SUITE.erl
new file mode 100644
index 0000000000..4fcd63e3af
--- /dev/null
+++ b/lib/test_server/src/things/random_kill_SUITE.erl
@@ -0,0 +1,81 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(random_kill_SUITE).
+-compile([export_all]).
+%%-define(line_trace,1).
+-include("test_server.hrl").
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+all(suite) -> [run].
+
+-define(iterations,25). %% Kill this many processes,
+ %% possibly with reboots in between
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+run(suite) -> [];
+run(Config) ->
+ registered(?iterations).
+
+registered(0) ->
+ ok;
+registered(N) ->
+ random:seed(3461*N,1159*N,351*N),
+ Pid = select_victim(registered),
+ test_server:resume_point(?MODULE,registered,[N-1]),
+ test_server:format("About to kill pid ~p (~p)\n~p",
+ [Pid,process_info(Pid,registered_name),info(Pid)]),
+ %%exit(Pid,kill),
+ registered(N-1).
+
+info(Pid) ->
+ Rest0 = tl(pid_to_list(Pid)),
+ {P1,Rest1} = get_until($.,Rest0),
+ {P2,Rest2} = get_until($.,Rest1),
+ {P3,_} = get_until($>,Rest2),
+ c:i(list_to_integer(P1),list_to_integer(P2),list_to_integer(P3)).
+
+get_until(Ch,L) ->
+ get_until(Ch,L,[]).
+get_until(Ch,[],Acc) ->
+ {lists:reverse(Acc),[]};
+get_until(Ch,[Ch|T],Acc) ->
+ {lists:reverse(Acc),T};
+get_until(Ch,[H|T],Acc) ->
+ get_until(Ch,T,[H|Acc]).
+
+select_victim(registered) ->
+ Pids =
+ lists:map(fun(Server)-> whereis(Server) end,registered()),
+ ImmunePids =
+ [self()|lists:map(fun(Job)-> element(2,Job) end,test_server:jobs())],
+ SuitablePids =
+ lists:filter(fun(Pid)-> case lists:member(Pid,ImmunePids) of
+ true -> false;
+ false -> true
+ end
+ end, Pids),
+ Selected = random:uniform(length(SuitablePids)),
+ io:format("Selected ~p if ~p",[Selected,length(SuitablePids)]),
+ lists:nth(Selected,SuitablePids).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
diff --git a/lib/test_server/src/things/soft.gs.txt b/lib/test_server/src/things/soft.gs.txt
new file mode 100644
index 0000000000..ec57884997
--- /dev/null
+++ b/lib/test_server/src/things/soft.gs.txt
@@ -0,0 +1,16 @@
+6> gs:start().
+RealTimeViolation, 478ms (after 1164 good)
+{1,<0.65.0>}
+RealTimeViolation, 352ms (after 0 good)
+RealTimeViolation, 492ms (after 0 good)
+RealTimeViolation, 166ms (after 0 good)
+RealTimeInfo, 18ms (after 7 good)
+RealTimeViolation, 115ms (after 13 good)
+7> application-specific initialization failed: couldn't connect to display ":0.0"
+RealTimeViolation, 20340ms (after 0 good)
+gs error: user backend died reason {port_handler,#Port,normal}
+
+RealTimeInfo, 31ms (after 21 good)
+RealTimeInfo, 21ms (after 69 good)
+RealTimeInfo, 21ms (after 119 good)
+RealTimeInfo, 21ms (after 169 good)
diff --git a/lib/test_server/src/things/verify.erl b/lib/test_server/src/things/verify.erl
new file mode 100644
index 0000000000..eac20c013e
--- /dev/null
+++ b/lib/test_server/src/things/verify.erl
@@ -0,0 +1,199 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(verify).
+
+-export([dir/0, dir/1]).
+
+%% usage verify:dir()
+%% or verify:dir(Dir)
+%%
+%% runs tests on all files with the extension ".t1"
+%% creates an error log file verify.log in the directory where the
+%% tests were run
+
+-import(lists, [reverse/1, foldl/3, map/2]).
+
+dir() ->
+ dir(".").
+
+dir(Dir) ->
+ case file:list_dir(Dir) of
+ {ok, Files} ->
+ VFiles = collect_vers(Files, []),
+ VFiles1 = map(fun(F) -> Dir ++ "/" ++ F end, VFiles),
+ Nerrs = foldl(fun(F, Sum) ->
+ case file(F) of
+ {file,_,had,N,errors} ->
+ Sum + N;
+ no_errors ->
+ Sum;
+ Other ->
+ Sum + 1
+ end
+ end, 0, VFiles1),
+ case Nerrs of
+ 0 -> no_errors;
+ _ -> {dir,Dir,had,Nerrs,errors}
+ end;
+ _ ->
+ {error, cannot,list_dir, Dir}
+ end.
+
+collect_vers([H|T], L) ->
+ case reverse(H) of
+ [$1,$t,$.|T1] -> collect_vers(T, [reverse(T1)|L]);
+ _ -> collect_vers(T, L)
+ end;
+collect_vers([], L) ->
+ L.
+
+file(File) ->
+ case file:open(File ++ ".t1", read) of
+ {ok, S} ->
+ io:format("Verifying: ~s\n", [File]),
+ ErrFile = File ++ ".errs",
+ {ok, E} = file:open(ErrFile, write),
+ Bind0 = erl_eval:new_bindings(),
+ NErrs = do(S, {E, File, Bind0, 0}, 1),
+ file:close(S),
+ file:close(E),
+ case NErrs of
+ 0 ->
+ file:delete(ErrFile),
+ no_errors;
+ _ ->
+ {file,File,had,NErrs,errors}
+ end;
+ _ ->
+ error_in_opening_file
+ end.
+
+do(S, Env, Line) ->
+ R = io:scan_erl_exprs(S, '', Line),
+ do1(R, S, Env).
+
+do1({eof,_}, _, {_,_,_,NErrs}) ->
+ NErrs;
+do1({ok,Toks,Next}, S, Env0) ->
+ E1 = handle_toks(Toks, Next, Env0),
+ do(S, E1, Next);
+do1({error, {Line,Mod,Args}, Next}, S, E) ->
+ io:format("*** ~w ~p~n", [Line,Mod:format_error(Args)]),
+ E1 = add_error(E),
+ do(S, E1, Next).
+
+add_error({Stream, File, Bindings, N}) -> {Stream, File, Bindings, N+1}.
+
+handle_toks(Toks, Line, Env0) ->
+ %% io:format("Toks:~p\n", [Toks]).
+ case erl_parse:parse_exprs(Toks) of
+ {ok, Exprs} ->
+ %% io:format("Got:~p\n", [Exprs]),
+ eval(Exprs, Line, Env0);
+ {error, {LineNo, Mod, What}} ->
+ Str = apply(Mod, format_error, [What]),
+ io:format("*** Line:~w ***~s\n", [LineNo, Str]),
+ add_error(Env0);
+ Parse_error ->
+ io:format("Parse Error:~p\n",[Parse_error]),
+ add_error(Env0)
+ end.
+
+forget([{var,_,Name}], B0) -> erl_eval:del_binding(Name, B0);
+forget([], _) -> erl_eval:new_bindings().
+
+eval([{call,_,{atom,_,f}, Args}], _, {Stream, Bind0, Errs}) ->
+ Bind1 = forget(Args, Bind0),
+ {Stream, Bind1, Errs};
+eval(Exprs, Line, {Stream, File, Bind0, NErrs}) ->
+ %% io:format("Bindings >> ~p\n", [Bind0]),
+ %% io:format("Exprs >> ~p\n", [Exprs]),
+ case catch erl_eval:exprs(Exprs, Bind0) of
+ {'EXIT', Reason} ->
+ out_both(Stream, "----------------------------------~n", []),
+ out_both(Stream, "File:~s Error in:~s~n", [File, pp(Exprs)]),
+ print_bindings(Stream, Exprs, Bind0),
+ print_lhs(Stream, Exprs),
+ out_both(Stream, '*** Rhs evaluated to:~p~n',[rhs(Exprs, Bind0)]),
+ {Stream, File, Bind0, NErrs+1};
+ {value, _, Bind1} ->
+ {Stream, File, Bind1, NErrs}
+ end.
+
+pp([H]) -> erl_pp:expr(H);
+pp([H|T]) -> [erl_pp:expr(H),$,|pp(T)];
+pp([]) -> [].
+
+print_bindings(E, Form, Bindings) ->
+ case varsin(Form) of
+ [] ->
+ true;
+ Vars ->
+ print_vars(E, Vars, Bindings)
+ end.
+
+print_vars(E, [Var|T], Bindings) ->
+ case erl_eval:binding(Var, Bindings) of
+ {value, Val} ->
+ out_both(E, '~s = ~p\n',[Var, Val]);
+ unbound ->
+ out_both(E, '~s *is unbound*\n', [Var])
+ end,
+ print_vars(E, T, Bindings);
+print_vars(_, [], _) ->
+ true.
+
+
+out_both(E, Format, Data) ->
+ io:format(Format, Data),
+ io:format(E, Format, Data).
+
+print_lhs(E, [{match, _, Lhs, Rhs}]) ->
+ %% io:format(">>>> here:~w\n",[Lhs]),
+ out_both(E, '*** Lhs was:~s\n',[erl_pp:expr(Lhs)]);
+print_lhs(E, _) ->
+ out_both(E, '** UNDEFINED **', []).
+
+
+rhs([{match, _, Lhs, Rhs}], Bindings) ->
+ case catch erl_eval:exprs([Rhs], Bindings) of
+ {value, Val, _} -> Val;
+ Other -> undefined()
+ end;
+rhs(_, _) ->
+ undefined().
+
+varsin(X) -> varsin(X, []).
+
+varsin({var,_,'_'}, L) ->
+ L;
+varsin({var,_,V}, L) ->
+ case lists:member(V, L) of
+ true -> L;
+ false -> [V|L]
+ end;
+varsin([H|T], L) ->
+ varsin(T, varsin(H, L));
+varsin(T, L) when tuple(T) ->
+ varsin(tuple_to_list(T), L);
+varsin(_, L) ->
+ L.
+
+undefined() ->
+ '** UNDEFINED **'.
diff --git a/lib/test_server/src/ts.config b/lib/test_server/src/ts.config
new file mode 100644
index 0000000000..30ef25a0b8
--- /dev/null
+++ b/lib/test_server/src/ts.config
@@ -0,0 +1,45 @@
+%% -*- erlang -*-
+{ipv6_hosts,[otptest06,otptest08,sauron,iluvatar]}.
+
+%%% Change these to suite the environment.
+%%% test_hosts are looked up using "ypmatch xx yy zz hosts"
+{test_hosts,
+ [bingo, hurin, turin, gandalf, super,
+ merry, nenya, sam, elrond, isildur]}.
+
+%% IPv4 host only - no ipv6 entry must exist!
+{test_host_ipv4_only,
+ {"isildur", %Short hostname
+ "isildur.du.uab.ericsson.se", %Long hostname
+ "134.138.177.24", %IP string
+ {134,138,177,24}, %IP tuple
+ ["isildur"], %Any aliases
+ "::ffff:134.138.177.24", %IPv6 string (compatibilty addr)
+ {0,0,0,0,0,65535,34442,45336} %IPv6 tuple
+ }}.
+
+{test_host_ipv6_only,
+ {"otptest06", %Short hostname
+ "otptest06.du.uab.ericsson.se", %Long hostname
+ "fec0::a00:20ff:feb2:b4a9", %IPv6 string
+ {65216,0,0,0,2560,8447,65202,46249}, %IPv6 tuple
+ ["otptest06-ip6"] %Aliases.
+ }}.
+
+
+
+{test_dummy_host, {"dummy",
+ "dummy.du.uab.ericsson.se",
+ "192.138.177.1",
+ {192,138,177,1},
+ ["dummy"],
+ "::ffff:192.138.177.1",
+ {0,0,0,0,0,65535,49290,45313}
+ }}.
+
+{test_dummy_ipv6_host, {"dummy6",
+ "dummy6.du.uab.ericsson.se",
+ "fec0::a00:20ff:feb2:6666",
+ {65216,0,0,0,2560,8447,65202,26214},
+ ["dummy6-ip6"]
+ }}.
diff --git a/lib/test_server/src/ts.erl b/lib/test_server/src/ts.erl
new file mode 100644
index 0000000000..1b750c3858
--- /dev/null
+++ b/lib/test_server/src/ts.erl
@@ -0,0 +1,695 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : ts.erl
+%%% Purpose : Frontend for running tests.
+%%%-------------------------------------------------------------------
+
+-module(ts).
+
+-export([run/0, run/1, run/2, run/3, run/4,
+ clean/0, clean/1,
+ tests/0, tests/1,
+ install/0, install/1, install/2, index/0,
+ estone/0, estone/1,
+ cross_cover_analyse/1,
+ help/0]).
+-export([i/0, l/1, r/0, r/1, r/2, r/3]).
+
+%%%----------------------------------------------------------------------
+%%% This module, ts, is the interface to all of the functionality of
+%%% the TS framework. The picture below shows the relationship of
+%%% the modules:
+%%%
+%%% +-- ts_install --+------ ts_autoconf_win32
+%%% | |
+%%% | +------ ts_autoconf_vxworks
+%%% |
+%%% ts ---+ +------ ts_erl_config
+%%% | | ts_lib
+%%% | +------ ts_make
+%%% | |
+%%% +-- ts_run -----+
+%%% | ts_filelib
+%%% +------ ts_make_erl
+%%% |
+%%% +------ ts_reports (indirectly)
+%%%
+%%%
+%%%
+%%% The modules ts_lib and ts_filelib contains utilities used by
+%%% the other modules.
+%%%
+%%% Module Description
+%%% ------ -----------
+%%% ts Frontend to the test server framework. Contains all
+%%% interface functions.
+%%% ts_install Installs the test suite. On Unix, `autoconf' is
+%%% is used; on Windows, ts_autoconf_win32 is used,
+%%% on VxWorks, ts_autoconf_vxworks is used.
+%%% The result is written to the file `variables'.
+%%% ts_run Supervises running of the tests.
+%%% ts_autconf_win32 An `autoconf' for Windows.
+%%% ts_autconf_cross_env `autoconf' for other platforms (cross environment)
+%%% ts_erl_config Finds out information about the Erlang system,
+%%% for instance the location of erl_interface.
+%%% This works for either an installed OTP or an Erlang
+%%% system running from Clearcase.
+%%% ts_make Interface to run the `make' program on Unix
+%%% and other platforms.
+%%% ts_make_erl A corrected version of the standar Erlang module
+%%% make (used for rebuilding test suites).
+%%% ts_reports Generates index pages in HTML, providing a summary
+%%% of the tests run.
+%%% ts_lib Miscellanous utility functions, each used by several
+%%% other modules.
+%%%----------------------------------------------------------------------
+
+-include_lib("kernel/include/file.hrl").
+-include("ts.hrl").
+
+-define(
+ install_help,
+ [
+ " ts:install() - Install TS for local target with no Options.\n"
+ " ts:install([Options])\n",
+ " - Install TS for local target with Options\n"
+ " ts:install({Architecture, Target_name})\n",
+ " - Install TS for a remote target architecture.\n",
+ " and target network name (e.g. {vxworks_cpu32, sauron}).\n",
+ " ts:install({Architecture, Target_name}, [Options])\n",
+ " - Install TS as above, and with Options.\n",
+ "\n",
+ "Installation options supported:\n",
+ " {longnames, true} - Use fully qualified hostnames\n",
+ " {hosts, [HostList]}\n"
+ " - Use theese hosts for distributed testing.\n"
+ " {verbose, Level} - Sets verbosity level for TS output (0,1,2), 0 is\n"
+ " quiet(default).\n"
+ " {slavetargets, SlaveTarges}\n"
+ " - Available hosts for starting slave nodes for\n"
+ " platforms which cannot have more than one erlang\n"
+ " node per host.\n"
+ " {crossroot, TargetErlRoot}\n"
+ " - Erlang root directory on target host\n"
+ " Mandatory for remote targets\n"
+ " {master, {MasterHost, MasterCookie}}\n"
+ " - Master host and cookie for targets which are\n"
+ " started as slave nodes (i.e. OSE/Delta targets\n"
+ " erl_boot_server must be started on master before\n"
+ " test is run.\n"
+ " Optional, default is controller host and then\n"
+ " erl_boot_server is started autmatically\n"
+ ]).
+
+help() ->
+ case filelib:is_file(?variables) of
+ false -> help(uninstalled);
+ true -> help(installed)
+ end.
+
+help(uninstalled) ->
+ H = ["TS is not installed yet. To install use:\n\n"],
+ show_help([H,?install_help]);
+help(installed) ->
+ H = ["Run functions:\n",
+ " ts:run() - Run all available tests.\n",
+ " ts:run(Spec) - Run all tests in given test spec file.\n",
+ " The spec file is actually ../*_test/Spec.spec\n",
+ " ts:run([Specs]) - Run all tests in all given test spec files.\n",
+ " ts:run(Spec, Mod) - Run a single test suite.\n",
+ " ts:run(Spec, Mod, Case)\n",
+ " - Run a single test case.\n",
+ " All above run functions can have the additional Options argument\n",
+ " which is a list of options.\n",
+ "\n",
+ "Run options supported:\n",
+ " batch - Do not start a new xterm\n",
+ " {verbose, Level} - Same as the verbosity option for install\n",
+ " verbose - Same as {verbose, 1}\n",
+ " {vars, Vars} - Variables in addition to the 'variables' file\n",
+ " Can be any of the install options\n",
+ " {trace, TraceSpec}- Start call trace on target and slave nodes\n",
+ " TraceSpec is the name of a file containing\n",
+ " trace specifications or a list of trace\n",
+ " specification elements.\n",
+ "\n",
+ "Supported trace information elements\n",
+ " {tp | tpl, Mod, [] | match_spec()}\n",
+ " {tp | tpl, Mod, Func, [] | match_spec()}\n",
+ " {tp | tpl, Mod, Func, Arity, [] | match_spec()}\n",
+ " {ctp | ctpl, Mod}\n",
+ " {ctp | ctpl, Mod, Func}\n",
+ " {ctp | ctpl, Mod, Func, Arity}\n",
+ "\n",
+ "Support functions\n",
+ " ts:tests() - Shows all available families of tests.\n",
+ " ts:tests(Spec) - Shows all available test modules in Spec,\n",
+ " i.e. ../Spec_test/*_SUITE.erl\n",
+ " ts:index() - Updates local index page.\n",
+ " ts:clean() - Cleans up all but the last tests run.\n",
+ " ts:clean(all) - Cleans up all test runs found.\n",
+ " ts:estone() - Run estone_SUITE in kernel application with\n"
+ " no run options\n",
+ " ts:estone(Opts) - Run estone_SUITE in kernel application with\n"
+ " the given run options\n",
+ " ts:cross_cover_analyse(Level)\n"
+ " - Used after ts:run with option cover or \n"
+ " cover_details. Analyses modules specified in\n"
+ " cross.cover.\n"
+ " Level can be 'overview' or 'details'.\n",
+ " \n"
+ "Installation (already done):\n"
+ ],
+ show_help([H,?install_help]).
+
+show_help(H) ->
+ io:put_chars(lists:flatten(H)).
+
+
+%% Installs tests.
+install() ->
+ ts_install:install(install_local,[]).
+install({Architecture, Target_name}) ->
+ ts_install:install({ts_lib:maybe_atom_to_list(Architecture),
+ ts_lib:maybe_atom_to_list(Target_name)}, []);
+install(Options) when is_list(Options) ->
+ ts_install:install(install_local,Options).
+install({Architecture, Target_name}, Options) when is_list(Options)->
+ ts_install:install({ts_lib:maybe_atom_to_list(Architecture),
+ ts_lib:maybe_atom_to_list(Target_name)}, Options).
+
+%% Updates the local index page.
+
+index() ->
+ check_and_run(fun(_Vars) -> ts_reports:make_index(), ok end).
+
+%%
+%% clean(all)
+%% Deletes all logfiles.
+%%
+clean(all) ->
+ delete_files(filelib:wildcard("*" ++ ?logdir_ext)).
+
+%% clean/0
+%%
+%% Cleans up run logfiles, all but the last run.
+clean() ->
+ clean1(filelib:wildcard("*" ++ ?logdir_ext)).
+
+clean1([Dir|Dirs]) ->
+ List0 = filelib:wildcard(filename:join(Dir, "run.*")),
+ case lists:reverse(lists:sort(List0)) of
+ [] -> ok;
+ [_Last|Rest] -> delete_files(Rest)
+ end,
+ clean1(Dirs);
+clean1([]) -> ok.
+
+%% run/0
+%% Runs all specs found by ts:tests(), if any, or returns
+%% {error, no_tests_available}. (batch)
+run() ->
+ case ts:tests() of
+ [] ->
+ {error, no_tests_available};
+ _ ->
+ check_and_run(fun(Vars) -> run_all(Vars) end)
+ end.
+run_all(_Vars) ->
+ run_some(tests(), [batch]).
+
+run_some([], _Opts) ->
+ ok;
+run_some([Spec|Specs], Opts) ->
+ case run(Spec, Opts) of
+ ok -> ok;
+ Error -> io:format("~p: ~p~n",[Spec,Error])
+ end,
+ run_some(Specs, Opts).
+
+%% Runs one test spec (interactive).
+run(Testspec) when is_atom(Testspec) ->
+ Options=check_test_get_opts(Testspec, []),
+ File = atom_to_list(Testspec),
+ run_test(File, ["SPEC current.spec NAME ",File], Options);
+
+%% This can be used from command line, e.g.
+%% erl -s ts run all_tests <config>
+%% When using the all_tests flag and running with cover, one can also
+%% use the cross_cover_analysis flag.
+run([all_tests|Config0]) ->
+ AllAtomsFun = fun(X) when is_atom(X) -> true;
+ (_) -> false
+ end,
+ Config1 =
+ case lists:all(AllAtomsFun,Config0) of
+ true ->
+ %% Could be from command line
+ lists:map(fun(Conf)->to_erlang_term(Conf) end,Config0)--[batch];
+ false ->
+ Config0--[batch]
+ end,
+ %% Make sure there is exactly one occurence of 'batch'
+ Config2 = [batch|Config1],
+
+ R = run(tests(),Config2),
+
+ case check_for_cross_cover_analysis_flag(Config2) of
+ false ->
+ ok;
+ Level ->
+ cross_cover_analyse(Level)
+ end,
+
+ R;
+
+%% ts:run(ListOfTests)
+run(List) when is_list(List) ->
+ run(List, [batch]).
+
+run(List, Opts) when is_list(List), is_list(Opts) ->
+ run_some(List, Opts);
+
+%% run/2
+%% Runs one test spec with Options
+run(Testspec, Config) when is_atom(Testspec), is_list(Config) ->
+ Options=check_test_get_opts(Testspec, Config),
+ File=atom_to_list(Testspec),
+ run_test(File, ["SPEC current.spec NAME ", File], Options);
+%% Runs one module in a spec (interactive)
+run(Testspec, Mod) when is_atom(Testspec), is_atom(Mod) ->
+ run_test({atom_to_list(Testspec), Mod},
+ ["SPEC current.spec NAME ", atom_to_list(Mod)],
+ [interactive]).
+
+%% run/3
+%% Run one module in a spec with Config
+run(Testspec,Mod,Config) when is_atom(Testspec), is_atom(Mod), is_list(Config) ->
+ Options=check_test_get_opts(Testspec, Config),
+ run_test({atom_to_list(Testspec), Mod},
+ ["SPEC current.spec NAME ", atom_to_list(Mod)],
+ Options);
+
+%% Runs one testcase in a module.
+run(Testspec, Mod, Case) when is_atom(Testspec), is_atom(Mod), is_atom(Case) ->
+ Options=check_test_get_opts(Testspec, []),
+ Args = ["CASE ",atom_to_list(Mod)," ",atom_to_list(Case)],
+ run_test(atom_to_list(Testspec), Args, Options).
+
+%% run/4
+%% Run one testcase in a module with Options.
+run(Testspec, Mod, Case, Config) when is_atom(Testspec), is_atom(Mod), is_atom(Case), is_list(Config) ->
+ Options=check_test_get_opts(Testspec, Config),
+ Args = ["CASE ",atom_to_list(Mod), " ",atom_to_list(Case)],
+ run_test(atom_to_list(Testspec), Args, Options).
+
+%% Check testspec to be valid and get possible Options
+%% from the config.
+check_test_get_opts(Testspec, Config) ->
+ validate_test(Testspec),
+ Mode = configmember(batch, {batch, interactive}, Config),
+ Vars = configvars(Config),
+ Trace = configtrace(Config),
+ KeepTopcase = configmember(keep_topcase, {keep_topcase,[]}, Config),
+ Cover = configcover(Testspec,Config),
+ lists:flatten([Vars,Mode,Trace,KeepTopcase,Cover]).
+
+to_erlang_term(Atom) ->
+ String = atom_to_list(Atom),
+ {ok, Tokens, _} = erl_scan:string(lists:append([String, ". "])),
+ {ok, Term} = erl_parse:parse_term(Tokens),
+ Term.
+
+%% Validate that a Testspec really is a testspec,
+%% and exit if not.
+validate_test(Testspec) ->
+ case lists:member(Testspec, tests()) of
+ true ->
+ ok;
+ false ->
+ io:format("This testspec does not seem to be "
+ "available.~n Please try ts:tests() "
+ "to see available tests.~n"),
+ exit(self(), {error, test_not_available})
+ end.
+
+configvars(Config) ->
+ case lists:keysearch(vars, 1, Config) of
+ {value, {vars, List}} ->
+ List0 = special_vars(Config),
+ Key = fun(T) -> element(1,T) end,
+ DelDupList =
+ lists:filter(fun(V) ->
+ case lists:keysearch(Key(V),1,List0) of
+ {value,_} -> false;
+ _ -> true
+ end
+ end, List),
+ {vars, [List0|DelDupList]};
+ _ ->
+ {vars, special_vars(Config)}
+ end.
+
+%% Allow some shortcuts in the Options...
+special_vars(Config) ->
+ SpecVars =
+ case lists:member(verbose, Config) of
+ true ->
+ [{verbose, 1}];
+ false ->
+ case lists:keysearch(verbose, 1, Config) of
+ {value, {verbose, Lvl}} ->
+ [{verbose, Lvl}];
+ _ ->
+ [{verbose, 0}]
+ end
+ end,
+ SpecVars1 =
+ case lists:keysearch(diskless, 1, Config) of
+ {value,{diskless, true}} ->
+ [{diskless, true} | SpecVars];
+ _ ->
+ SpecVars
+ end,
+ case lists:keysearch(testcase_callback, 1, Config) of
+ {value,{testcase_callback, CBM, CBF}} ->
+ [{ts_testcase_callback, {CBM,CBF}} | SpecVars1];
+ {value,{testcase_callback, CB}} ->
+ [{ts_testcase_callback, CB} | SpecVars1];
+ _ ->
+ SpecVars1
+ end.
+
+configtrace(Config) ->
+ case lists:keysearch(trace,1,Config) of
+ {value,Value} -> Value;
+ false -> []
+ end.
+
+configcover(Testspec,[cover|_]) ->
+ {cover,Testspec,default_coverfile(Testspec),overview};
+configcover(Testspec,[cover_details|_]) ->
+ {cover,Testspec,default_coverfile(Testspec),details};
+configcover(Testspec,[{cover,File}|_]) ->
+ {cover,Testspec,File,overview};
+configcover(Testspec,[{cover_details,File}|_]) ->
+ {cover,Testspec,File,details};
+configcover(Testspec,[_H|T]) ->
+ configcover(Testspec,T);
+configcover(_Testspec,[]) ->
+ [].
+
+default_coverfile(Testspec) ->
+ {ok,Cwd} = file:get_cwd(),
+ CoverFile = filename:join([filename:dirname(Cwd),
+ atom_to_list(Testspec)++"_test",
+ atom_to_list(Testspec)++".cover"]),
+ case filelib:is_file(CoverFile) of
+ true ->
+ CoverFile;
+ false ->
+ none
+ end.
+
+configmember(Member, {True, False}, Config) ->
+ case lists:member(Member, Config) of
+ true ->
+ True;
+ false ->
+ False
+ end.
+
+
+check_for_cross_cover_analysis_flag(Config) ->
+ check_for_cross_cover_analysis_flag(Config,false,false).
+check_for_cross_cover_analysis_flag([cover|Config],false,false) ->
+ check_for_cross_cover_analysis_flag(Config,overview,false);
+check_for_cross_cover_analysis_flag([cover|_Config],false,true) ->
+ overview;
+check_for_cross_cover_analysis_flag([cover_details|Config],false,false) ->
+ check_for_cross_cover_analysis_flag(Config,details,false);
+check_for_cross_cover_analysis_flag([cover_details|_Config],false,true) ->
+ details;
+check_for_cross_cover_analysis_flag([cross_cover_analysis|Config],false,_) ->
+ check_for_cross_cover_analysis_flag(Config,false,true);
+check_for_cross_cover_analysis_flag([cross_cover_analysis|_Config],Level,_) ->
+ Level;
+check_for_cross_cover_analysis_flag([_|Config],Level,CrossFlag) ->
+ check_for_cross_cover_analysis_flag(Config,Level,CrossFlag);
+check_for_cross_cover_analysis_flag([],_,_) ->
+ false.
+
+%% Returns a list of available test suites.
+
+tests() ->
+ {ok, Cwd} = file:get_cwd(),
+ ts_lib:specs(Cwd).
+
+tests(Spec) ->
+ {ok, Cwd} = file:get_cwd(),
+ ts_lib:suites(Cwd, atom_to_list(Spec)).
+
+
+%%
+%% estone/0, estone/1
+%% Opts = same as Opts or Config for the run(...) function,
+%% e.g. [batch]
+%%
+estone() -> run(emulator,estone_SUITE).
+estone(Opts) when is_list(Opts) -> run(emulator,estone_SUITE,Opts).
+
+%%
+%% cross_cover_analyse/1
+%% Level = details | overview
+%% Can be called on any node after a test (with cover) is
+%% completed. The node's current directory must be the same as when
+%% the tests were run.
+%%
+cross_cover_analyse([Level]) ->
+ cross_cover_analyse(Level);
+cross_cover_analyse(Level) ->
+ test_server_ctrl:cross_cover_analyse(Level).
+
+
+%%% Implementation.
+
+check_and_run(Fun) ->
+ case file:consult(?variables) of
+ {ok, Vars} ->
+ check_and_run(Fun, Vars);
+ {error, Error} when is_atom(Error) ->
+ {error, not_installed};
+ {error, Reason} ->
+ {error, {bad_installation, file:format_error(Reason)}}
+ end.
+
+check_and_run(Fun, Vars) ->
+ Platform = ts_install:platform_id(Vars),
+ case lists:keysearch(platform_id, 1, Vars) of
+ {value, {_, Platform}} ->
+ case catch apply(Fun, [Vars]) of
+ {'EXIT', Reason} ->
+ exit(Reason);
+ Other ->
+ Other
+ end;
+ {value, {_, OriginalPlatform}} ->
+ io:format("These test suites were installed for '~s'.\n",
+ [OriginalPlatform]),
+ io:format("But the current platform is '~s'.\nPlease "
+ "install for this platform before running "
+ "any tests.\n", [Platform]),
+ {error, inconsistent_platforms};
+ false ->
+ {error, {bad_installation, no_platform}}
+ end.
+
+run_test(File, Args, Options) ->
+ check_and_run(fun(Vars) -> run_test(File, Args, Options, Vars) end).
+
+run_test(File, Args, Options, Vars) ->
+ ts_run:run(File, Args, Options, Vars).
+
+
+delete_files([]) -> ok;
+delete_files([Item|Rest]) ->
+ case file:delete(Item) of
+ ok ->
+ delete_files(Rest);
+ {error,eperm} ->
+ file:change_mode(Item, 8#777),
+ delete_files(filelib:wildcard(filename:join(Item, "*"))),
+ file:del_dir(Item),
+ ok;
+ {error,eacces} ->
+ %% We'll see about that!
+ file:change_mode(Item, 8#777),
+ case file:delete(Item) of
+ ok -> ok;
+ {error,_} ->
+ erlang:yield(),
+ file:change_mode(Item, 8#777),
+ file:delete(Item),
+ ok
+ end;
+ {error,_} -> ok
+ end,
+ delete_files(Rest).
+
+
+%% This module provides some convenient shortcuts to running
+%% the test server from within a started Erlang shell.
+%% (This are here for backwards compatibility.)
+%%
+%% r()
+%% r(Opts)
+%% r(SpecOrMod)
+%% r(SpecOrMod, Opts)
+%% r(Mod, Case)
+%% r(Mod, Case, Opts)
+%% Each of these functions starts the test server if it
+%% isn't already running, then runs the test case(s) selected
+%% by the aguments.
+%% SpecOrMod can be a module name or the name of a test spec file,
+%% with the extension .spec or .spec.OsType. The module Mod will
+%% be reloaded before running the test cases.
+%% Opts = [Opt],
+%% Opt = {Cover,AppOrCoverFile} | {Cover,App,CoverFile}
+%% Cover = cover | cover_details
+%% AppOrCoverFile = App | CoverFile
+%% App = atom(), an application name
+%% CoverFile = string(), name of a cover file
+%% (see doc of test_server_ctrl:cover/2/3)
+%%
+%% i()
+%% Shows information about the jobs being run, by dumping
+%% the process information for the test_server.
+%%
+%% l(Mod)
+%% This function reloads a module just like c:l/1, but works
+%% even for a module in one of the sticky library directories
+%% (for instance, lists can be reloaded).
+
+%% Runs all tests cases in the current directory.
+
+r() ->
+ r([]).
+r(Opts) when is_list(Opts), is_atom(hd(Opts)) ->
+ ensure_ts_started(Opts),
+ test_server_ctrl:add_dir("current_dir", ".");
+
+%% Checks if argument is a spec file or a module
+%% (spec file must be named "*.spec" or "*.spec.OsType")
+%% If module, reloads module and runs all test cases in it.
+%% If spec, runs all test cases in it.
+
+r(SpecOrMod) ->
+ r(SpecOrMod,[]).
+r(SpecOrMod,Opts) when is_list(Opts) ->
+ ensure_ts_started(Opts),
+ case filename:extension(SpecOrMod) of
+ [] ->
+ l(SpecOrMod),
+ test_server_ctrl:add_module(SpecOrMod);
+ ".spec" ->
+ test_server_ctrl:add_spec(SpecOrMod);
+ _ ->
+ Spec2 = filename:rootname(SpecOrMod),
+ case filename:extension(Spec2) of
+ ".spec" ->
+ %% *.spec.Type
+ test_server_ctrl:add_spec(SpecOrMod);
+ _ ->
+ {error, unknown_filetype}
+ end
+ end;
+
+%% Reloads the given module and runs the given test case in it.
+
+r(Mod, Case) ->
+ r(Mod,Case,[]).
+r(Mod, Case, Opts) ->
+ ensure_ts_started(Opts),
+ l(Mod),
+ test_server_ctrl:add_case(Mod, Case).
+
+%% Shows information about the jobs being run.
+
+i() ->
+ ensure_ts_started([]),
+ hformat("Job", "Current", "Total", "Success", "Failed", "Skipped"),
+ i(test_server_ctrl:jobs()).
+
+i([{Name, Pid}|Rest]) when is_pid(Pid) ->
+ {dictionary, PI} = process_info(Pid, dictionary),
+ {value, {_, CaseNum}} = lists:keysearch(test_server_case_num, 1, PI),
+ {value, {_, Cases}} = lists:keysearch(test_server_cases, 1, PI),
+ {value, {_, Failed}} = lists:keysearch(test_server_failed, 1, PI),
+ {value, {_, {UserSkipped,AutoSkipped}}} = lists:keysearch(test_server_skipped, 1, PI),
+ {value, {_, Ok}} = lists:keysearch(test_server_ok, 1, PI),
+ nformat(Name, CaseNum, Cases, Ok, Failed, UserSkipped+AutoSkipped),
+ i(Rest);
+i([]) ->
+ ok.
+
+hformat(A1, A2, A3, A4, A5, A6) ->
+ io:format("~-20s ~8s ~8s ~8s ~8s ~8s~n", [A1,A2,A3,A4,A5,A6]).
+
+nformat(A1, A2, A3, A4, A5, A6) ->
+ io:format("~-20s ~8w ~8w ~8w ~8w ~8w~n", [A1,A2,A3,A4,A5,A6]).
+
+%% Force load of a module even if it is in a sticky directory.
+
+l(Mod) ->
+ case do_load(Mod) of
+ {error, sticky_directory} ->
+ Dir = filename:dirname(code:which(Mod)),
+ code:unstick_dir(Dir),
+ do_load(Mod),
+ code:stick_dir(Dir);
+ X ->
+ X
+ end.
+
+
+ensure_ts_started(Opts) ->
+ Pid = case whereis(test_server_ctrl) of
+ undefined ->
+ test_server_ctrl:start();
+ P when is_pid(P) ->
+ P
+ end,
+ case Opts of
+ [{Cover,AppOrCoverFile}] when Cover==cover; Cover==cover_details ->
+ test_server_ctrl:cover(AppOrCoverFile,cover_type(Cover));
+ [{Cover,App,CoverFile}] when Cover==cover; Cover==cover_details ->
+ test_server_ctrl:cover(App,CoverFile,cover_type(Cover));
+ _ ->
+ ok
+ end,
+ Pid.
+
+cover_type(cover) -> overview;
+cover_type(cover_details) -> details.
+
+do_load(Mod) ->
+ code:purge(Mod),
+ code:load_file(Mod).
diff --git a/lib/test_server/src/ts.hrl b/lib/test_server/src/ts.hrl
new file mode 100644
index 0000000000..885a726c54
--- /dev/null
+++ b/lib/test_server/src/ts.hrl
@@ -0,0 +1,36 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%% Defines ripped out from test_server (these must remain the same
+%% as in test_server).
+
+-define(logdir_ext, ".logs").
+-define(suitelog_name, "suite.log").
+-define(last_file, "last_name").
+-define(last_link, "last_link").
+-define(last_test, "last_test").
+-define(run_summary, "suite.summary").
+-define(cover_total,"total_cover.log").
+-define(variables, "variables").
+-define(LF, [10]). % Newline in VxWorks script
+-define(CHAR_PER_LINE, 60). % Characters per VxWorks script building line
+-define(CROSS_COOKIE, "cross"). % cookie used when cross platform testing
+-define(TS_PORT, 7887).
+-define(TEST_SERVER_SCRIPT, "test_server_vx.script").
+
diff --git a/lib/test_server/src/ts.unix.config b/lib/test_server/src/ts.unix.config
new file mode 100644
index 0000000000..b4325f065f
--- /dev/null
+++ b/lib/test_server/src/ts.unix.config
@@ -0,0 +1,4 @@
+%% -*- erlang -*-
+
+%% Always run a (VNC) X server on host
+{xserver, "frumgar.du.uab.ericsson.se:66"}.
diff --git a/lib/test_server/src/ts.vxworks.config b/lib/test_server/src/ts.vxworks.config
new file mode 100644
index 0000000000..b0b66e07ad
--- /dev/null
+++ b/lib/test_server/src/ts.vxworks.config
@@ -0,0 +1,19 @@
+%% -*- erlang -*-
+
+%%% There is no equivalent command to ypmatch on Win32... :-(
+{hardcoded_hosts,
+ [{"134.138.177.74","strider"},
+ {"134.138.177.72", "elrond"},
+ {"134.138.177.67", "sam"},
+ {"134.138.176.215", "nenya"},
+ {"134.138.176.192", "merry"},
+ {"134.138.177.35", "lw4"},
+ {"134.138.177.35", "lw5"},
+ {"134.138.176.16", "super"},
+ {"134.138.177.16", "gandalf"},
+ {"134.138.177.92", "turin"},
+ {"134.138.177.86", "mallor"}]}.
+
+{hardcoded_ipv6_hosts,
+ [{"fe80::a00:20ff:feb2:b4a9","otptest06"},
+ {"fe80::a00:20ff:feb2:a621","otptest08"}]}.
diff --git a/lib/test_server/src/ts.win32.config b/lib/test_server/src/ts.win32.config
new file mode 100644
index 0000000000..2802c4a75a
--- /dev/null
+++ b/lib/test_server/src/ts.win32.config
@@ -0,0 +1,15 @@
+%% -*- erlang -*-
+
+%%% There is no equivalent command to ypmatch on Win32... :-(
+{hardcoded_hosts,
+ [{"134.138.177.24","isildur"},
+ {"134.138.177.72", "elrond"},
+ {"134.138.176.215", "nenya"},
+ {"134.138.176.192", "merry"},
+ {"134.138.176.16", "super"},
+ {"134.138.177.16", "gandalf"},
+ {"134.138.177.92", "turin"}]}.
+
+{hardcoded_ipv6_hosts,
+ [{"fe80::a00:20ff:feb2:b4a9","otptest06"},
+ {"fe80::a00:20ff:feb2:a621","otptest08"}]}.
diff --git a/lib/test_server/src/ts_autoconf_vxworks.erl b/lib/test_server/src/ts_autoconf_vxworks.erl
new file mode 100644
index 0000000000..f4535cd89a
--- /dev/null
+++ b/lib/test_server/src/ts_autoconf_vxworks.erl
@@ -0,0 +1,191 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%% Purpose : Autoconf for cross environments.
+
+-module(ts_autoconf_vxworks).
+-export([configure/1]).
+%%% Supported cross platforms:
+-define(PLATFORMS, ["vxworks_cpu32", "vxworks_ppc860", "vxworks_ppc603",
+ "vxworks_sparc", "vxworks_ppc750", "vxworks_simso"]).
+-include("ts.hrl").
+
+%% takes an argument {Target_arch, Target_host} (e.g. {vxworks_ppc860, thorin}).
+configure({Target_arch, Target_host}) ->
+ case variables({Target_arch, Target_host}) of
+ {ok, Vars} ->
+ ts_lib:subst_file("conf_vars.in", "conf_vars", Vars);
+ Error ->
+ Error
+ end.
+
+variables(Cross_spec) ->
+ run_tests(Cross_spec, tests(), []).
+
+run_tests(Cross_spec, [{Prompt, Tester}|Rest], Vars) ->
+ io:format("checking ~s... ", [Prompt]),
+ case catch Tester(Cross_spec, Vars) of
+ {'EXIT', Reason} ->
+ io:format("FAILED~nExit status: ~p~n", [Reason]),
+ {error, auto_conf_failed};
+ {Result, NewVars} ->
+ io:format("~s~n", [lists:concat([Result])]),
+ run_tests(Cross_spec, Rest, NewVars)
+ end;
+run_tests(_Cross_spec, [], Vars) ->
+ {ok, Vars}.
+
+
+%%% The tests.
+
+tests() ->
+ [{"supported target architecture", fun target_architecture/2},
+ {"cross target host to run tests on", fun target_host/2},
+ {"CPU type", fun cpu/2},
+ {"for cross-compiling gcc", fun find_gcc/2},
+ {"for cross-linker", fun find_ld/2},
+ {"for object extension", fun find_obj/2},
+ {"for shared libraries extension", fun find_dll/2},
+ {"for executables extension", fun find_exe/2},
+ {"for make", fun find_make/2}].
+
+target_architecture({Architecture, _Target_host}, Vars) ->
+ case lists:member(Architecture, ?PLATFORMS) of
+ true ->
+ {Architecture, [{host_os, os_type(Architecture)}, {host, Architecture}|Vars]};
+ false ->
+ {"unsupported_platform", Vars}
+ end.
+
+target_host({_Architecture, Target_host}, Vars) ->
+ {Target_host, [{target_host, Target_host} | Vars]}.
+
+cpu({Arch, _Target_host}, Vars) ->
+ Cpu = processor(Arch),
+ {Cpu, [{host_cpu, Cpu}|Vars]}.
+
+find_gcc({Arch, _Target_host}, Vars) ->
+ Gcc = "cc" ++ gnu_suffix(Arch),
+ case os:find_executable(Gcc) of
+ false ->
+ {no, Vars};
+ Path when is_list(Path) ->
+ Cflags = cflags(Arch),
+ {Path, [{'CC', Gcc},
+ {'CFLAGS', Cflags},
+ {'EI_CFLAGS', Cflags},
+ {'ERTS_CFLAGS', Cflags},
+ {'DEFS', ""},
+ {'ERTS_LIBS', ""},
+ {'LIBS', ""},
+ {'SHLIB_CFLAGS', Cflags},
+ {test_c_compiler, "{gnuc, undefined}"} | Vars]}
+ end.
+
+find_ld({Arch, _Target_host}, Vars) ->
+ Linker = "ld" ++ gnu_suffix(Arch),
+ case os:find_executable(Linker) of
+ false ->
+ {no, Vars};
+ Path when is_list(Path) ->
+ {Path, [{'LD', Linker},
+ {'CROSSLDFLAGS', ldflags(Arch)},
+ {'SHLIB_EXTRACT_ALL', ""},
+ {'SHLIB_LD', Linker},
+ {'SHLIB_LDFLAGS', ""},
+ {'SHLIB_LDLIBS', ""} | Vars]}
+ end.
+
+find_obj({Arch, _Target_host}, Vars) ->
+ Obj = obj_ext(Arch),
+ {Obj, [{obj, Obj}|Vars]}.
+
+find_dll({Arch, _Target_host}, Vars) ->
+ Dll = dll_ext(Arch),
+ {Dll, [{'SHLIB_SUFFIX', Dll}|Vars]}.
+
+find_exe({Arch, _Target_host}, Vars) ->
+ Exe = exe_ext(Arch),
+ {Exe, [{exe, Exe}|Vars]}.
+
+find_make(_, Vars) ->
+ {"make", [{make_command, "make"} | Vars]}.
+
+%%% some utility functions
+gnu_suffix(Arch) ->
+ {_, _, _, _, Suffix, _Cpu, _Cflags, _} = cross_data(Arch),
+ Suffix.
+
+processor(Arch) ->
+ {_, _, _, _, _Suffix, Cpu, _Cflags, _} = cross_data(Arch),
+ Cpu.
+
+cflags(Arch) ->
+ {_, _, _, _, _Suffix, _Cpu, Cflags, _} = cross_data(Arch),
+ Cflags.
+
+ldflags(Arch) ->
+ {_, _, _, _, _Suffix, _Cpu, _Cflags, Ldflags} = cross_data(Arch),
+ Ldflags.
+
+os_type(Arch) ->
+ {Os_type, _, _, _, _, _, _, _} = cross_data(Arch),
+ Os_type.
+
+obj_ext(Arch) ->
+ {_, _, Obj, _, _, _, _, _} = cross_data(Arch),
+ Obj.
+
+dll_ext(Arch) ->
+ {_, _, _, Dll, _, _, _, _} = cross_data(Arch),
+ Dll.
+
+exe_ext(Arch) ->
+ {_, Exe, _, _, _, _, _, _} = cross_data(Arch),
+ Exe.
+
+cross_data(Arch) ->
+ case Arch of
+ "vxworks_cpu32" ->
+ {"VxWorks", "", ".o", ".eld", "68k", "cpu32",
+ "-DCPU=CPU32 -DVXWORKS -I$(WIND_BASE)/target/h -mnobitfield -fno-builtin -nostdinc -fvolatile -msoft-float",
+ "-r -d"};
+ "vxworks_ppc860" ->
+ {"VxWorks", "", ".o", ".eld", "ppc", "ppc860",
+ "-DCPU=PPC860 -DVXWORKS -I$(WIND_BASE)/target/h -mcpu=860 -fno-builtin -fno-for-scope -msoft-float -D_GNU_TOOL -nostdinc",
+ "-r -d"};
+ "vxworks_ppc603" ->
+ {"VxWorks", "", ".o", ".eld", "ppc", "ppc603",
+ "-DCPU=PPC603 -DVXWORKS -I$(WIND_BASE)/target/h -fno-builtin -fno-for-scope -D_GNU_TOOL -nostdinc",
+ "-r -d"};
+ "vxworks_sparc" ->
+ %%% The Sparc Architecture is included for private use (i.e. not Tornado 1.0.1 compatible).
+ {"VxWorks", "", ".o", ".eld", "sparc", "sparc",
+ "-DCPU=SPARC -DVXWORKS -I/home/gandalf/bsproj/BS.2/UOS/vw/5.2/h -fno-builtin -nostdinc",
+ "-r -d"};
+ "vxworks_ppc750" ->
+ {"VxWorks", "", ".o", ".eld", "ppc", "ppc604",
+ "-DCPU=PPC604 -DVXWORKS -DTOOL_FAMILY=gnu -DTOOL=gnu -I$(WIND_BASE)/target/h -fno-builtin -fno-for-scope -D_GNU_TOOL",
+ "-r -d"};
+ "vxworks_simso" ->
+ {"VxWorks", "", ".o", ".eld", "simso", "simso",
+ "-DCPU=SIMSPARCSOLARIS -DVXWORKS -DTOOL_FAMILY=gnu -DTOOL=gnu -I$(WIND_BASE)/target/h -I$(WIND_GCC_INCLUDE) -fno-builtin -fno-for-scope -D_GNU_TOOL",
+ "-r -d"}
+
+ end.
diff --git a/lib/test_server/src/ts_autoconf_win32.erl b/lib/test_server/src/ts_autoconf_win32.erl
new file mode 100644
index 0000000000..9103542fd2
--- /dev/null
+++ b/lib/test_server/src/ts_autoconf_win32.erl
@@ -0,0 +1,254 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%% Purpose : Autoconf for Windows.
+
+-module(ts_autoconf_win32).
+-export([configure/0]).
+
+-include("ts.hrl").
+
+configure() ->
+ case variables() of
+ {ok, Vars} ->
+ ts_lib:subst_file("conf_vars.in", "conf_vars", Vars);
+ Error ->
+ Error
+ end.
+
+variables() ->
+ run_tests(tests(), []).
+
+run_tests([{Prompt, Tester}|Rest], Vars) ->
+ io:format("checking ~s... ", [Prompt]),
+ case catch Tester(Vars) of
+ {'EXIT', Reason} ->
+ io:format("FAILED~nExit status: ~p~n", [Reason]),
+ {error, auto_conf_failed};
+ {Result, NewVars} ->
+ io:format("~s~n", [lists:concat([Result])]),
+ run_tests(Rest, NewVars)
+ end;
+run_tests([], Vars) ->
+ {ok, Vars}.
+
+%%% The tests.
+
+tests() ->
+ [{"host system type", fun system_type/1},
+ {"CPU type", fun cpu/1},
+ {"for C compiler", fun c_compiler/1},
+ {"for make program", fun make/1},
+ {"for location of SSL libraries", fun ssl/1},
+ {"for location of Java compiler", fun javac/1}].
+
+system_type(Vars) ->
+ Os = case os:type() of
+ {win32, nt} ->
+ case os:version() of
+ {4,_,_} -> "Windows NT";
+ {5,0,_} -> "Windows 2000";
+ {5,1,_} -> "Windows XP";
+ {5,2,_} -> "Windows 2003";
+ {6,0,_} -> "Windows Vista";
+ {_,_,_} -> "Windows NCC-1701-D"
+ end;
+ {win32, windows} ->
+ case os:version() of
+ {4,0,_} -> "Windows 95";
+ {4,10,_} -> "Windows 98"
+ end;
+ {win32, _} -> "Windows"
+ end,
+ {Os, [{host_os, Os}, {host, "win32"}|Vars]}.
+
+cpu(Vars) ->
+ Arch = os:getenv("PROCESSOR_ARCHITECTURE"),
+ Level0 = os:getenv("PROCESSOR_Level"),
+ Cpu = case {Arch, Level0} of
+ {"x86", Level} when is_list(Level) ->
+ "i" ++ Level ++ "86";
+ {Other, _Level} when is_list(Other) ->
+ Other;
+ {false, _} ->
+ "i386"
+ end,
+ {Cpu, [{host_cpu, Cpu}|Vars]}.
+
+c_compiler(Vars) ->
+ try
+ CompTests = [{msc, fun visual_cxx/1},
+ {gnuc, fun mingw32/1}],
+ %% First try to find the same compiler that the system
+ %% was built with...
+ UsedCompiler = case erlang:system_info(c_compiler_used) of
+ {UsedCmplr, _} ->
+ case lists:keysearch(UsedCmplr, 1, CompTests) of
+ {value, {UsedCmplr, CompTest}} ->
+ CompTest(Vars);
+ _ ->
+ ok
+ end,
+ UsedCmplr;
+ undefined ->
+ undefined
+ end,
+ %% ... then try to find a compiler...
+ lists:foreach(fun ({Cmplr, _CmplrTst}) when Cmplr =:= UsedCompiler ->
+ ok; % Have already checked for this one
+ ({_Cmplr, CmplrTst}) ->
+ CmplrTst(Vars)
+ end,
+ CompTests),
+ {no, Vars}
+ catch
+ throw:{_Path, _NewVars} = Res -> Res
+ end.
+
+visual_cxx(Vars) ->
+ case os:find_executable("cl") of
+ false ->
+ {no, Vars};
+ Path when is_list(Path) ->
+ {DEFAULT_THR_LIB,
+ ERTS_THR_LIB,
+ DLL,
+ DBG_LINK,
+ DBG_COMP,
+ OPT} =
+ case is_debug_build() of
+ true ->
+ {"-MTd ",
+ "-MDd ",
+ "-LDd ",
+ "-debug -pdb:none ",
+ "-Z7 -DDEBUG",
+ " "};
+ false ->
+ {"-MT ",
+ "-MD ",
+ "-LD ",
+ " ",
+ " ",
+ "-Ox "}
+ end,
+ WIN32 = "-D__WIN32__ ",
+ ERTS_CFLAGS = ERTS_THR_LIB ++ WIN32 ++ OPT ++ DBG_COMP,
+ LIBS = "ws2_32.lib",
+ CC = "cl -nologo",
+ throw({Path, [{'CC', CC},
+ {'LD', CC},
+ {'SHLIB_LD', CC},
+ {'SHLIB_LDFLAGS', ERTS_THR_LIB ++ DLL},
+ {'SHLIB_LDLIBS', "-link " ++ DBG_LINK ++ "kernel32.lib"},
+ {'SHLIB_EXTRACT_ALL', ""},
+ {'CFLAGS', DEFAULT_THR_LIB ++ WIN32 ++ DBG_COMP},
+ {'EI_CFLAGS', DEFAULT_THR_LIB ++ WIN32 ++ DBG_COMP},
+ {'ERTS_CFLAGS', ERTS_CFLAGS},
+ {'SHLIB_CFLAGS', ERTS_CFLAGS++DLL},
+ {'CROSSLDFLAGS', ""},
+ {'DEFS', common_c_defs()},
+ {'SHLIB_SUFFIX', ".dll"},
+ {'ERTS_LIBS', ERTS_THR_LIB ++ LIBS},
+ {'LIBS', DEFAULT_THR_LIB ++ "-link " ++ DBG_LINK ++ LIBS},
+ {obj,".obj"},
+ {exe, ".exe"},
+ {test_c_compiler, "{msc, undefined}"}
+ | Vars]})
+ end.
+
+mingw32(Vars) ->
+ Gcc = "mingw32-gcc",
+ case os:find_executable(Gcc) of
+ false ->
+ {no, Vars};
+ Path when is_list(Path) ->
+ {DBG_COMP,
+ OPT} =
+ case is_debug_build() of
+ true ->
+ {"-DDEBUG",
+ " "};
+ false ->
+ {" ",
+ "-O2 "}
+ end,
+ WIN32 = "-D__WIN32__ ",
+ ERTS_CFLAGS = WIN32 ++ "-g " ++ OPT ++ DBG_COMP,
+ LIBS = "-lws2_32",
+ CC = Gcc,
+ throw({Path, [{'CC', CC},
+ {'LD', CC},
+ {'SHLIB_LD', CC},
+ {'SHLIB_LDFLAGS', "-shared "},
+ {'SHLIB_LDLIBS', " -lkernel32"},
+ {'SHLIB_EXTRACT_ALL', ""},
+ {'CFLAGS', WIN32 ++ DBG_COMP},
+ {'EI_CFLAGS', WIN32 ++ DBG_COMP},
+ {'ERTS_CFLAGS', ERTS_CFLAGS},
+ {'SHLIB_CFLAGS', ERTS_CFLAGS},
+ {'CROSSLDFLAGS', ""},
+ {'DEFS', common_c_defs()},
+ {'SHLIB_SUFFIX', ".dll"},
+ {'ERTS_LIBS', LIBS},
+ {'LIBS', LIBS},
+ {obj,".o"},
+ {exe, ".exe"},
+ {test_c_compiler, "{gnuc, undefined}"}
+ | Vars]})
+ end.
+
+common_c_defs() ->
+ "-DHAVE_STRERROR=1".
+
+make(Vars) ->
+ try
+ find_make("nmake -nologo", Vars),
+ find_make("mingw32-make", Vars)
+ catch
+ throw:{_Path, _NewVars} = Res -> Res
+ end.
+
+find_make(MakeCmd, Vars) ->
+ [Make|_] = string:tokens(MakeCmd, " \t"),
+ case os:find_executable(Make) of
+ false ->
+ {no, Vars};
+ Path when is_list(Path) ->
+ throw({Path, [{make_command, MakeCmd} | Vars]})
+ end.
+
+ssl(Vars) ->
+ {"win32",[{'SSLEAY_ROOT',"win32"}|Vars]}.
+
+javac(Vars) ->
+ case os:find_executable("javac") of
+ false ->
+ {no, Vars};
+ Path when is_list(Path) ->
+ {Path, [{'JAVAC', "javac"} | Vars]}
+ end.
+
+is_debug_build() ->
+ case catch string:str(erlang:system_info(system_version), "debug") of
+ Int when is_integer(Int), Int > 0 ->
+ true;
+ _ ->
+ false
+ end.
diff --git a/lib/test_server/src/ts_erl_config.erl b/lib/test_server/src/ts_erl_config.erl
new file mode 100644
index 0000000000..4fc46fc5d6
--- /dev/null
+++ b/lib/test_server/src/ts_erl_config.erl
@@ -0,0 +1,398 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%% Purpose : Updates variable list with variables depending on
+%%% running Erlang system.
+
+-module(ts_erl_config).
+
+
+-export([variables/2]).
+
+%% Returns a list of key, value pairs.
+
+variables(Base0, OsType) ->
+ Base1 = erl_include(Base0),
+ Base2 = get_app_vars(fun erl_interface/2, Base1, OsType),
+ Base3 = get_app_vars(fun ic/2, Base2, OsType),
+ Base4 = get_app_vars(fun jinterface/2, Base3, OsType),
+ Base5 = dl_vars(Base4, OsType),
+ Base6 = emu_vars(Base5),
+ Base7 = get_app_vars(fun ssl/2, Base6, OsType),
+ Base8 = erts_lib(Base7, OsType),
+ Base = separators(Base8, OsType),
+ [{'EMULATOR', tl(code:objfile_extension())},
+ {emu_threads, atom_to_list(erlang:system_info(threads))},
+ {type_marker, case is_debug_build() of
+ true ->
+ ".debug";
+ false ->
+ ""
+ end}
+ | Base].
+
+get_app_vars(AppFun, Vars, OsType) ->
+ case catch AppFun(Vars,OsType) of
+ Res when is_list(Res) ->
+ Res;
+ {cannot_find_app, App} ->
+ io:format("* WARNING: Cannot find ~p!~n", [App]),
+ Vars;
+ {'EXIT', Reason} ->
+ exit(Reason);
+ Garbage ->
+ exit({unexpected_internal_error, Garbage})
+ end.
+
+dl_vars(Vars, _) ->
+ ShlibRules0 = ".SUFFIXES:\n" ++
+ ".SUFFIXES: @dll@ @obj@ .c\n\n" ++
+ ".c@dll@:\n" ++
+ "\t@CC@ -c @SHLIB_CFLAGS@ $(SHLIB_EXTRA_CFLAGS) -I@erl_include@ @DEFS@ $<\n" ++
+ "\t@SHLIB_LD@ @CROSSLDFLAGS@ @SHLIB_LDFLAGS@ $(SHLIB_EXTRA_LDFLAGS) -o $@ $*@obj@ @SHLIB_LDLIBS@ $(SHLIB_EXTRA_LDLIBS)",
+
+ ShlibRules = ts_lib:subst(ShlibRules0, Vars),
+ [{'SHLIB_RULES', ShlibRules}|Vars].
+
+erts_lib_name(multi_threaded, win32) ->
+ link_library("erts_MD" ++ case is_debug_build() of
+ true -> "d";
+ false -> ""
+ end,
+ win32);
+erts_lib_name(single_threaded, win32) ->
+ link_library("erts_ML" ++ case is_debug_build() of
+ true -> "d";
+ false -> ""
+ end,
+ win32);
+erts_lib_name(multi_threaded, OsType) ->
+ link_library("erts_r", OsType);
+erts_lib_name(single_threaded, OsType) ->
+ link_library("erts", OsType).
+
+erts_lib(Vars,OsType) ->
+ {ErtsLibInclude,
+ ErtsLibIncludeGenerated,
+ ErtsLibIncludeInternal,
+ ErtsLibIncludeInternalGenerated,
+ ErtsLibPath,
+ ErtsLibInternalPath}
+ = case erl_root(Vars) of
+ {installed, _Root} ->
+ Erts = lib_dir(Vars, erts),
+ ErtsInclude = filename:join([Erts, "include"]),
+ ErtsIncludeInternal = filename:join([ErtsInclude, "internal"]),
+ ErtsLib = filename:join([Erts, "lib"]),
+ ErtsLibInternal = filename:join([ErtsLib, "internal"]),
+ {ErtsInclude,
+ ErtsInclude,
+ ErtsIncludeInternal,
+ ErtsIncludeInternal,
+ ErtsLib,
+ ErtsLibInternal};
+ {Type, Root, Target} when Type == clearcase; Type == srctree ->
+ Erts = filename:join([Root, "erts"]),
+ ErtsInclude = filename:join([Erts, "include"]),
+ ErtsIncludeTarget = filename:join([ErtsInclude, Target]),
+ ErtsIncludeInternal = filename:join([ErtsInclude,
+ "internal"]),
+ ErtsIncludeInternalTarget = filename:join([ErtsIncludeInternal,
+ Target]),
+ ErtsLib = filename:join([Erts, "lib", Target]),
+ ErtsLibInternal = filename:join([Erts,
+ "lib",
+ "internal",
+ Target]),
+ {ErtsInclude,
+ ErtsIncludeTarget,
+ ErtsIncludeInternal,
+ ErtsIncludeInternalTarget,
+ ErtsLib,
+ ErtsLibInternal}
+ end,
+ [{erts_lib_include,
+ filename:nativename(ErtsLibInclude)},
+ {erts_lib_include_generated,
+ filename:nativename(ErtsLibIncludeGenerated)},
+ {erts_lib_include_internal,
+ filename:nativename(ErtsLibIncludeInternal)},
+ {erts_lib_include_internal_generated,
+ filename:nativename(ErtsLibIncludeInternalGenerated)},
+ {erts_lib_path, filename:nativename(ErtsLibPath)},
+ {erts_lib_internal_path, filename:nativename(ErtsLibInternalPath)},
+ {erts_lib_multi_threaded, erts_lib_name(multi_threaded, OsType)},
+ {erts_lib_single_threaded, erts_lib_name(single_threaded, OsType)}
+ | Vars].
+
+erl_include(Vars) ->
+ Include =
+ case erl_root(Vars) of
+ {installed, Root} ->
+ filename:join([Root, "usr", "include"]);
+ {Type, Root, Target} when Type == clearcase; Type == srctree ->
+ filename:join([Root, "erts", "emulator", "beam"])
+ ++ " -I" ++ filename:join([Root, "erts", "emulator"])
+ ++ system_include(Root, Vars)
+ ++ " -I" ++ filename:join([Root, "erts", "include"])
+ ++ " -I" ++ filename:join([Root, "erts", "include", Target])
+ end,
+ [{erl_include, filename:nativename(Include)}|Vars].
+
+
+system_include(Root, Vars) ->
+ SysDir =
+ case ts_lib:var(os, Vars) of
+ "Windows" ++ _T -> "sys/win32";
+ "VxWorks" -> "sys.vxworks";
+ "OSE" -> "sys/ose";
+ _ -> "sys/unix"
+ end,
+ " -I" ++ filename:nativename(filename:join([Root, "erts", "emulator", SysDir])).
+
+erl_interface(Vars,OsType) ->
+ {Incl, {LibPath, MkIncl}} =
+ case lib_dir(Vars, erl_interface) of
+ {error, bad_name} ->
+ throw({cannot_find_app, erl_interface});
+ Dir ->
+ {filename:join(Dir, "include"),
+ case erl_root(Vars) of
+ {installed, _Root} ->
+ {filename:join(Dir, "lib"),
+ filename:join(Dir, "src")};
+ {srctree, _Root, _Target} when OsType =:= vxworks ->
+ {filename:join(Dir, "lib"),
+ filename:join([Dir, "src"])};
+ {Type, _Root, Target} when Type == clearcase; Type == srctree ->
+ {filename:join([Dir, "obj", Target]),
+ filename:join([Dir, "src", Target])}
+ end}
+ end,
+ Lib = link_library("erl_interface",OsType),
+ Lib1 = link_library("ei",OsType),
+ {LibDrv, Lib1Drv} =
+ case erlang:system_info(threads) of
+ false ->
+ case OsType of
+ {unix,_} ->
+ {link_library("erl_interface_st",OsType),
+ link_library("ei_st",OsType)};
+ _ ->
+ {Lib, Lib1}
+ end;
+ true ->
+ case OsType of
+ {win32, _} ->
+ {link_library("erl_interface_md",OsType),
+ link_library("ei_md",OsType)};
+ _ ->
+ {Lib, Lib1}
+ end
+ end,
+ ThreadLib = case OsType of
+ % FIXME: FreeBSD uses gcc flag '-pthread' or linking with
+ % "libc_r". So it has to be last of libs. This is an
+ % temporary solution, should be configured elsewhere.
+
+ % This temporary solution have now failed!
+ % A new temporary solution is installed ...
+ % {unix,freebsd} -> "-lc_r";
+ {unix,freebsd} ->
+ "-lpthread";
+ {unix,_} ->
+ "-lpthread";
+ _ ->
+ "" % VxWorks or OSE
+ end,
+ CrossCompile = case OsType of
+ vxworks -> "true";
+ ose -> "true";
+ _ -> "false"
+ end,
+ [{erl_interface_libpath, filename:nativename(LibPath)},
+ {erl_interface_sock_libs, sock_libraries(OsType)},
+ {erl_interface_lib, Lib},
+ {erl_interface_eilib, Lib1},
+ {erl_interface_lib_drv, LibDrv},
+ {erl_interface_eilib_drv, Lib1Drv},
+ {erl_interface_threadlib, ThreadLib},
+ {erl_interface_include, filename:nativename(Incl)},
+ {erl_interface_mk_include, filename:nativename(MkIncl)},
+ {erl_interface_cross_compile, CrossCompile} | Vars].
+
+ic(Vars, OsType) ->
+ {ClassPath, LibPath, Incl} =
+ case lib_dir(Vars, ic) of
+ {error, bad_name} ->
+ throw({cannot_find_app, ic});
+ Dir ->
+ {filename:join([Dir, "priv", "ic.jar"]),
+ case erl_root(Vars) of
+ {installed, _Root} ->
+ filename:join([Dir, "priv", "lib"]);
+ {Type, _Root, Target} when Type == clearcase; Type == srctree ->
+ filename:join([Dir, "priv", "lib", Target])
+ end,
+ filename:join(Dir, "include")}
+ end,
+ [{ic_classpath, filename:nativename(ClassPath)},
+ {ic_libpath, filename:nativename(LibPath)},
+ {ic_lib, link_library("ic", OsType)},
+ {ic_include_path, filename:nativename(Incl)}|Vars].
+
+jinterface(Vars, _OsType) ->
+ ClassPath =
+ case lib_dir(Vars, jinterface) of
+ {error, bad_name} ->
+ throw({cannot_find_app, jinterface});
+ Dir ->
+ filename:join([Dir, "priv", "OtpErlang.jar"])
+ end,
+ [{jinterface_classpath, filename:nativename(ClassPath)}|Vars].
+
+%% Unused!
+% ig_vars(Vars) ->
+% {Lib0, Incl} =
+% case erl_root(Vars) of
+% {installed, Root} ->
+% Base = filename:join([Root, "usr"]),
+% {filename:join([Base, "lib"]),
+% filename:join([Base, "include"])};
+% {Type, Root, Target} when Type == clearcase; Type == srctree ->
+% {filename:join([Root, "lib", "ig", "obj", Target]),
+% filename:join([Root, "lib", "ig", "include"])}
+% end,
+% [{ig_libdir, filename:nativename(Lib0)},
+% {ig_include, filename:nativename(Incl)}|Vars].
+
+lib_dir(Vars, Lib) ->
+ LibLibDir = case Lib of
+ erts ->
+ filename:join([code:root_dir(),
+ "erts-" ++ erlang:system_info(version)]);
+ _ ->
+ code:lib_dir(Lib)
+ end,
+ case {get_var(crossroot, Vars), LibLibDir} of
+ {{error, _}, _} -> %no crossroot
+ LibLibDir;
+ {_, {error, _}} -> %no lib
+ LibLibDir;
+ {CrossRoot, _} ->
+ %% XXX: Ugly. So ugly I won't comment it
+ %% /Patrik
+ CLibDirList = case Lib of
+ erts ->
+ [CrossRoot, "erts"];
+ _ ->
+ [CrossRoot, "lib", atom_to_list(Lib)]
+ end,
+ CLibDir = filename:join(CLibDirList),
+ Cmd = "ls -d " ++ CLibDir ++ "*",
+ XLibDir = lists:last(string:tokens(os:cmd(Cmd),"\n")),
+ case file:list_dir(XLibDir) of
+ {error, enoent} ->
+ [];
+ _ ->
+ XLibDir
+ end
+ end.
+
+erl_root(Vars) ->
+ Root = code:root_dir(),
+ case ts_lib:erlang_type() of
+ {clearcase, _Version} ->
+ Target = get_var(target, Vars),
+ {clearcase, Root, Target};
+ {srctree, _Version} ->
+ Target = get_var(target, Vars),
+ {srctree, Root, Target};
+ {_, _Version} ->
+ case get_var(crossroot,Vars) of
+ {error, notfound} ->
+ {installed, Root};
+ CrossRoot ->
+ {installed, CrossRoot}
+ end
+ end.
+
+
+get_var(Key, Vars) ->
+ case lists:keysearch(Key, 1, Vars) of
+ {value, {Key, Value}} ->
+ Value;
+ _ ->
+ {error, notfound}
+ end.
+
+
+sock_libraries({win32, _}) ->
+ "ws2_32.lib";
+sock_libraries({unix, _}) ->
+ ""; % Included in general libraries if needed.
+sock_libraries(vxworks) ->
+ "";
+sock_libraries(ose) ->
+ "";
+sock_libraries(_Other) ->
+ exit({sock_libraries, not_supported}).
+
+
+link_library(LibName,{win32, _}) ->
+ LibName ++ ".lib";
+link_library(LibName,{unix, _}) ->
+ "lib" ++ LibName ++ ".a";
+link_library(LibName,vxworks) ->
+ "lib" ++ LibName ++ ".a";
+link_library(_LibName,ose) ->
+ "";
+link_library(_LibName,_Other) ->
+ exit({link_library, not_supported}).
+
+%% Returns emulator specific variables.
+emu_vars(Vars) ->
+ [{is_source_build, is_source_build()},
+ {erl_name, atom_to_list(lib:progname())}|Vars].
+
+is_source_build() ->
+ string:str(erlang:system_info(system_version), "[source]") > 0.
+
+is_debug_build() ->
+ case catch string:str(erlang:system_info(system_version), "debug") of
+ Int when is_integer(Int), Int > 0 ->
+ true;
+ _ ->
+ false
+ end.
+%%
+%% ssl_libdir
+%%
+ssl(Vars, _OsType) ->
+ case lib_dir(Vars, ssl) of
+ {error, bad_name} ->
+ throw({cannot_find_app, ssl});
+ Dir ->
+ [{ssl_libdir, filename:nativename(Dir)}| Vars]
+ end.
+
+separators(Vars, {win32,_}) ->
+ [{'DS',"\\"},{'PS',";"}|Vars];
+separators(Vars, _) ->
+ [{'DS',"/"},{'PS',":"}|Vars].
diff --git a/lib/test_server/src/ts_install.erl b/lib/test_server/src/ts_install.erl
new file mode 100644
index 0000000000..94926eba80
--- /dev/null
+++ b/lib/test_server/src/ts_install.erl
@@ -0,0 +1,348 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(ts_install).
+
+
+-export([install/2, platform_id/1]).
+
+-include("ts.hrl").
+
+install(install_local, Options) ->
+ install(os:type(), Options);
+
+install(TargetSystem, Options) ->
+ io:format("Running configure for cross architecture, network target name~n"
+ "~p~n", [TargetSystem]),
+ case autoconf(TargetSystem) of
+ {ok, Vars0} ->
+ OsType = os_type(TargetSystem),
+ Vars1 = ts_erl_config:variables(merge(Vars0,Options),OsType),
+ {Options1, Vars2} = add_vars(Vars1, Options),
+ Vars3 = lists:flatten([Options1|Vars2]),
+ write_terms(?variables, Vars3);
+ {error, Reason} ->
+ {error, Reason}
+ end.
+
+os_type({unix,_}=OsType) -> OsType;
+os_type({win32,_}=OsType) -> OsType;
+os_type(_Other) -> vxworks.
+
+merge(Vars,[]) ->
+ Vars;
+merge(Vars,[{crossroot,X}| Tail]) ->
+ merge([{crossroot, X} | Vars], Tail);
+merge(Vars,[_X | Tail]) ->
+ merge(Vars,Tail).
+
+%% Autoconf for various platforms.
+%% unix uses the configure script
+%% win32 uses ts_autoconf_win32
+%% VxWorks uses ts_autoconf_vxworks.
+
+autoconf(TargetSystem) ->
+ case autoconf1(TargetSystem) of
+ ok ->
+ autoconf2(file:read_file("conf_vars"));
+ Error ->
+ Error
+ end.
+
+autoconf1({win32, _}) ->
+ ts_autoconf_win32:configure();
+autoconf1({unix, _}) ->
+ unix_autoconf();
+autoconf1(Other) ->
+ ts_autoconf_vxworks:configure(Other).
+
+autoconf2({ok, Bin}) ->
+ get_vars(binary_to_list(Bin), name, [], []);
+autoconf2(Error) ->
+ Error.
+
+get_vars([$:|Rest], name, Current, Result) ->
+ Name = list_to_atom(lists:reverse(Current)),
+ get_vars(Rest, value, [], [Name|Result]);
+get_vars([$\r|Rest], value, Current, Result) ->
+ get_vars(Rest, value, Current, Result);
+get_vars([$\n|Rest], value, Current, [Name|Result]) ->
+ Value = lists:reverse(Current),
+ get_vars(Rest, name, [], [{Name, Value}|Result]);
+get_vars([C|Rest], State, Current, Result) ->
+ get_vars(Rest, State, [C|Current], Result);
+get_vars([], name, [], Result) ->
+ {ok, Result};
+get_vars(_, _, _, _) ->
+ {error, fatal_bad_conf_vars}.
+
+unix_autoconf() ->
+ Configure = filename:absname("configure"),
+ Args = case catch erlang:system_info(threads) of
+ false -> "";
+ _ -> " --enable-shlib-thread-safety"
+ end
+ ++ case catch string:str(erlang:system_info(system_version),
+ "debug") > 0 of
+ false -> "";
+ _ -> " --enable-debug-mode"
+ end,
+ case filelib:is_file(Configure) of
+ true ->
+ Env = macosx_cflags(),
+ Port = open_port({spawn, Configure ++ Args},
+ [stream, eof, {env,Env}]),
+ ts_lib:print_data(Port);
+ false ->
+ {error, no_configure_script}
+ end.
+
+macosx_cflags() ->
+ case os:type() of
+ {unix, darwin} ->
+ %% To ensure that the drivers we build can be loaded
+ %% by the emulator, add either -m32 or -m64 to CFLAGS.
+ WordSize = erlang:system_info(wordsize),
+ Mflag = "-m" ++ integer_to_list(8*WordSize),
+ [{"CFLAGS", Mflag},{"LDFLAGS", Mflag}];
+ _ ->
+ []
+ end.
+
+write_terms(Name, Terms) ->
+ case file:open(Name, [write]) of
+ {ok, Fd} ->
+ Result = write_terms1(Fd, Terms),
+ file:close(Fd),
+ Result;
+ {error, Reason} ->
+ {error, Reason}
+ end.
+
+write_terms1(Fd, [Term|Rest]) ->
+ ok = io:format(Fd, "~p.\n", [Term]),
+ write_terms1(Fd, Rest);
+write_terms1(_, []) ->
+ ok.
+
+add_vars(Vars0, Opts0) ->
+ {Opts,LongNames} =
+ case lists:keymember(longnames, 1, Opts0) of
+ true ->
+ {lists:keydelete(longnames, 1, Opts0),true};
+ false ->
+ {Opts0,false}
+ end,
+ {PlatformId, PlatformLabel, PlatformFilename, Version} =
+ platform([{longnames, LongNames}|Vars0]),
+ {Opts, [{longnames, LongNames},
+ {platform_id, PlatformId},
+ {platform_filename, PlatformFilename},
+ {rsh_name, get_rsh_name()},
+ {platform_label, PlatformLabel},
+ {erl_flags, []},
+ {erl_release, Version},
+ {ts_testcase_callback, get_testcase_callback()} | Vars0]}.
+
+get_testcase_callback() ->
+ case os:getenv("TS_TESTCASE_CALLBACK") of
+ ModFunc when is_list(ModFunc), ModFunc /= "" ->
+ case string:tokens(ModFunc, " ") of
+ [_Mod,_Func] -> ModFunc;
+ _ -> ""
+ end;
+ _ ->
+ case init:get_argument(ts_testcase_callback) of
+ {ok,[[Mod,Func]]} -> Mod ++ " " ++ Func;
+ _ -> ""
+ end
+ end.
+
+get_rsh_name() ->
+ case os:getenv("ERL_RSH") of
+ false ->
+ case ts_lib:erlang_type() of
+ {clearcase, _} ->
+ "ctrsh";
+ {_, _} ->
+ "rsh"
+ end;
+ Str ->
+ Str
+ end.
+
+platform_id(Vars) ->
+ {Id,_,_,_} = platform(Vars),
+ Id.
+
+platform(Vars) ->
+ Hostname = hostname(),
+
+ {Type,Version} = ts_lib:erlang_type(),
+ Cpu = ts_lib:var('CPU', Vars),
+ Os = ts_lib:var(os, Vars),
+
+ ErlType = to_upper(atom_to_list(Type)),
+ OsType = ts_lib:initial_capital(Os),
+ CpuType = ts_lib:initial_capital(Cpu),
+ LinuxDist = linux_dist(),
+ ExtraLabel = extra_platform_label(),
+ Schedulers = schedulers(),
+ BindType = bind_type(),
+ KP = kernel_poll(),
+ IOTHR = io_thread(),
+ LC = lock_checking(),
+ MT = modified_timing(),
+ AsyncThreads = async_threads(),
+ HeapType = heap_type_label(),
+ Debug = debug(),
+ CpuBits = word_size(),
+ Common = lists:concat([Hostname,"/",OsType,"/",CpuType,CpuBits,LinuxDist,
+ Schedulers,BindType,KP,IOTHR,LC,MT,AsyncThreads,
+ HeapType,Debug,ExtraLabel]),
+ PlatformId = lists:concat([ErlType, " ", Version, Common]),
+ PlatformLabel = ErlType ++ Common,
+ PlatformFilename = platform_as_filename(PlatformId),
+ {PlatformId, PlatformLabel, PlatformFilename, Version}.
+
+platform_as_filename(Label) ->
+ lists:map(fun($ ) -> $_;
+ ($/) -> $_;
+ (C) when $A =< C, C =< $Z -> C - $A + $a;
+ (C) -> C end,
+ Label).
+
+to_upper(String) ->
+ lists:map(fun(C) when $a =< C, C =< $z -> C - $a + $A;
+ (C) -> C end,
+ String).
+
+word_size() ->
+ case erlang:system_info(wordsize) of
+ 4 -> "";
+ 8 -> "/64"
+ end.
+
+linux_dist() ->
+ case os:type() of
+ {unix,linux} ->
+ linux_dist_1([fun linux_dist_suse/0]);
+ _ -> ""
+ end.
+
+linux_dist_1([F|T]) ->
+ case F() of
+ "" -> linux_dist_1(T);
+ Str -> Str
+ end;
+linux_dist_1([]) -> "".
+
+linux_dist_suse() ->
+ case filelib:is_file("/etc/SuSE-release") of
+ false -> "";
+ true ->
+ Ver0 = os:cmd("awk '/^VERSION/ {print $3}' /etc/SuSE-release"),
+ [_|Ver1] = lists:reverse(Ver0),
+ Ver = lists:reverse(Ver1),
+ "/Suse" ++ Ver
+ end.
+
+hostname() ->
+ case catch inet:gethostname() of
+ {ok, Hostname} when is_list(Hostname) ->
+ "/" ++ lists:takewhile(fun (C) -> C /= $. end, Hostname);
+ _ ->
+ "/localhost"
+ end.
+
+heap_type_label() ->
+ case catch erlang:system_info(heap_type) of
+ hybrid -> "/Hybrid";
+ _ -> "" %private
+ end.
+
+async_threads() ->
+ case catch erlang:system_info(threads) of
+ true -> "/A"++integer_to_list(erlang:system_info(thread_pool_size));
+ _ -> ""
+ end.
+
+schedulers() ->
+ case catch erlang:system_info(smp_support) of
+ true ->
+ case {erlang:system_info(schedulers),
+ erlang:system_info(schedulers_online)} of
+ {S,S} ->
+ "/S"++integer_to_list(S);
+ {S,O} ->
+ "/S"++integer_to_list(S) ++ ":" ++
+ integer_to_list(O)
+ end;
+ _ -> ""
+ end.
+
+bind_type() ->
+ case catch erlang:system_info(scheduler_bind_type) of
+ thread_no_node_processor_spread -> "/sbttnnps";
+ no_node_processor_spread -> "/sbtnnps";
+ no_node_thread_spread -> "/sbtnnts";
+ processor_spread -> "/sbtps";
+ thread_spread -> "/sbtts";
+ no_spread -> "/sbtns";
+ _ -> ""
+ end.
+
+
+debug() ->
+ case string:str(erlang:system_info(system_version), "debug") of
+ 0 -> "";
+ _ -> "/Debug"
+ end.
+
+lock_checking() ->
+ case catch erlang:system_info(lock_checking) of
+ true -> "/LC";
+ _ -> ""
+ end.
+
+modified_timing() ->
+ case catch erlang:system_info(modified_timing_level) of
+ N when is_integer(N) ->
+ "/T" ++ integer_to_list(N);
+ _ -> ""
+ end.
+
+kernel_poll() ->
+ case catch erlang:system_info(kernel_poll) of
+ true -> "/KP";
+ _ -> ""
+ end.
+
+io_thread() ->
+ case catch erlang:system_info(io_thread) of
+ true -> "/IOTHR";
+ _ -> ""
+ end.
+
+extra_platform_label() ->
+ case os:getenv("TS_EXTRA_PLATFORM_LABEL") of
+ [] -> "";
+ [_|_]=Label -> "/" ++ Label;
+ false -> ""
+ end.
+
diff --git a/lib/test_server/src/ts_lib.erl b/lib/test_server/src/ts_lib.erl
new file mode 100644
index 0000000000..082c9e0519
--- /dev/null
+++ b/lib/test_server/src/ts_lib.erl
@@ -0,0 +1,335 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(ts_lib).
+
+-include_lib("kernel/include/file.hrl").
+-include("ts.hrl").
+
+-export([error/1, var/2, erlang_type/0,
+ initial_capital/1, interesting_logs/1,
+ specs/1, suites/2, last_test/1,
+ force_write_file/2, force_delete/1,
+ subst_file/3, subst/2, print_data/1,
+ maybe_atom_to_list/1, progress/4
+ ]).
+
+error(Reason) ->
+ throw({error, Reason}).
+
+%% Returns the value for a variable
+
+var(Name, Vars) ->
+ case lists:keysearch(Name, 1, Vars) of
+ {value, {Name, Value}} ->
+ Value;
+ false ->
+ error({bad_installation, {undefined_var, Name, Vars}})
+ end.
+
+%% Returns the level of verbosity (0-X)
+verbosity(Vars) ->
+ % Check for a single verbose option.
+ case lists:member(verbose, Vars) of
+ true ->
+ 1;
+ false ->
+ case lists:keysearch(verbose, 1, Vars) of
+ {value, {verbose, Level}} ->
+ Level;
+ _ ->
+ 0
+ end
+ end.
+
+% Displays output to the console if verbosity is equal or more
+% than Level.
+progress(Vars, Level, Format, Args) ->
+ V=verbosity(Vars),
+ if
+ V>=Level ->
+ io:format(Format, Args);
+ true ->
+ ok
+ end.
+
+%% Returns: {Type, Version} where Type is otp|src
+
+erlang_type() ->
+ {_, Version} = init:script_id(),
+ RelDir = filename:join([code:root_dir(), "releases"]), % Only in installed
+ SysDir = filename:join([code:root_dir(), "system"]), % Nonexisting link/dir outside ClearCase
+ case {filelib:is_file(RelDir),filelib:is_file(SysDir)} of
+ {true,_} -> {otp, Version}; % installed OTP
+ {_,true} -> {clearcase, Version};
+ _ -> {srctree, Version}
+ end.
+
+%% Upcases the first letter in a string.
+
+initial_capital([C|Rest]) when $a =< C, C =< $z ->
+ [C-$a+$A|Rest];
+initial_capital(String) ->
+ String.
+
+%% Returns a list of the "interesting logs" in a directory,
+%% i.e. those that correspond to spec files.
+
+interesting_logs(Dir) ->
+ Logs = filelib:wildcard(filename:join(Dir, [$*|?logdir_ext])),
+ Interesting =
+ case specs(Dir) of
+ [] ->
+ Logs;
+ Specs0 ->
+ Specs = ordsets:from_list(Specs0),
+ [L || L <- Logs, ordsets:is_element(filename_to_atom(L), Specs)]
+ end,
+ sort_tests(Interesting).
+
+specs(Dir) ->
+ Specs = filelib:wildcard(filename:join([filename:dirname(Dir),
+ "*_test", "*.{dyn,}spec"])),
+ sort_tests([filename_to_atom(Name) || Name <- Specs]).
+
+suites(Dir, Spec) ->
+ Glob=filename:join([filename:dirname(Dir), Spec++"_test",
+ "*_SUITE.erl"]),
+ Suites=filelib:wildcard(Glob),
+ [filename_to_atom(Name) || Name <- Suites].
+
+filename_to_atom(Name) ->
+ list_to_atom(filename:rootname(filename:basename(Name))).
+
+%% Sorts a list of either log files directories or spec files.
+
+sort_tests(Tests) ->
+ Sorted = lists:usort([{suite_order(filename_to_atom(X)), X} ||
+ X <- Tests]),
+ [X || {_, X} <- Sorted].
+
+%% This defines the order in which tests should be run and be presented
+%% in index files.
+
+suite_order(emulator) -> 0;
+suite_order(test_server) -> 1;
+suite_order(kernel) -> 4;
+suite_order(stdlib) -> 6;
+suite_order(compiler) -> 8;
+suite_order(hipe) -> 9;
+suite_order(erl_interface) -> 12;
+suite_order(jinterface) -> 14;
+suite_order(sasl) -> 16;
+suite_order(tools) -> 18;
+suite_order(runtime_tools) -> 19;
+suite_order(parsetools) -> 20;
+suite_order(pman) -> 21;
+suite_order(debugger) -> 22;
+suite_order(toolbar) -> 23;
+suite_order(ic) -> 24;
+suite_order(orber) -> 26;
+suite_order(inets) -> 28;
+suite_order(asn1) -> 30;
+suite_order(os_mon) -> 32;
+suite_order(snmp) -> 38;
+suite_order(mnemosyne) -> 40;
+suite_order(mnesia_session) -> 42;
+suite_order(mnesia) -> 44;
+suite_order(system) -> 999; %% IMPORTANT: system SHOULD always be last!
+suite_order(_) -> 200.
+
+last_test(Dir) ->
+ last_test(filelib:wildcard(filename:join(Dir, "run.[1-2]*")), false).
+
+last_test([Run|Rest], false) ->
+ last_test(Rest, Run);
+last_test([Run|Rest], Latest) when Run > Latest ->
+ last_test(Rest, Run);
+last_test([_|Rest], Latest) ->
+ last_test(Rest, Latest);
+last_test([], Latest) ->
+ Latest.
+
+%% Do the utmost to ensure that the file is written, by deleting or
+%% renaming an old file with the same name.
+
+force_write_file(Name, Contents) ->
+ force_delete(Name),
+ file:write_file(Name, Contents).
+
+force_delete(Name) ->
+ case file:delete(Name) of
+ {error, eacces} ->
+ force_rename(Name, Name ++ ".old.", 0);
+ Other ->
+ Other
+ end.
+
+force_rename(From, To, Number) ->
+ Dest = [To|integer_to_list(Number)],
+ case file:read_file_info(Dest) of
+ {ok, _} ->
+ force_rename(From, To, Number+1);
+ {error, _} ->
+ file:rename(From, Dest)
+ end.
+
+%% Substitute all occurrences of @var@ in the In file, using
+%% the list of variables in Vars, producing the output file Out.
+%% Returns: ok | {error, Reason}
+
+subst_file(In, Out, Vars) ->
+ case file:read_file(In) of
+ {ok, Bin} ->
+ Subst = subst(binary_to_list(Bin), Vars, []),
+ case file:write_file(Out, Subst) of
+ ok ->
+ ok;
+ {error, Reason} ->
+ {error, {file_write, Reason}}
+ end;
+ Error ->
+ Error
+ end.
+
+subst(String, Vars) ->
+ subst(String, Vars, []).
+
+subst([$@, $_|Rest], Vars, Result) ->
+ subst_var([$_|Rest], Vars, Result, []);
+subst([$@, C|Rest], Vars, Result) when $A =< C, C =< $Z ->
+ subst_var([C|Rest], Vars, Result, []);
+subst([$@, C|Rest], Vars, Result) when $a =< C, C =< $z ->
+ subst_var([C|Rest], Vars, Result, []);
+subst([C|Rest], Vars, Result) ->
+ subst(Rest, Vars, [C|Result]);
+subst([], _Vars, Result) ->
+ lists:reverse(Result).
+
+subst_var([$@|Rest], Vars, Result, VarAcc) ->
+ Key = list_to_atom(lists:reverse(VarAcc)),
+ {Result1,Rest1} = do_subst_var(Key, Rest, Vars, Result, VarAcc),
+ subst(Rest1, Vars, Result1);
+
+subst_var([C|Rest], Vars, Result, VarAcc) ->
+ subst_var(Rest, Vars, Result, [C|VarAcc]);
+subst_var([], Vars, Result, VarAcc) ->
+ subst([], Vars, [VarAcc++[$@|Result]]).
+
+%% handle conditional
+do_subst_var(Cond, Rest, Vars, Result, _VarAcc) when Cond == 'IFEQ' ;
+ Cond == 'IFNEQ' ->
+ {Bool,Comment,Rest1} = do_test(Rest, Vars, Cond),
+ Rest2 = extract_clause(Bool, Rest1),
+ {lists:reverse(Comment, Result),Rest2};
+%% variable substitution
+do_subst_var(Key, Rest, Vars, Result, VarAcc) ->
+ case lists:keysearch(Key, 1, Vars) of
+ {value, {Key, Value}} ->
+ {lists:reverse(Value, Result),Rest};
+ false ->
+ {[$@|VarAcc++[$@|Result]],Rest}
+ end.
+
+%% check arguments in "@IF[N]EQ@ (Arg1, Arg2)" for equality
+do_test(Rest, Vars, Test) ->
+ {Arg1,Rest1} = get_arg(Rest, Vars, $,, []),
+ {Arg2,Rest2} = get_arg(Rest1, Vars, 41, []), % $)
+ Result = case Arg1 of
+ Arg2 when Test == 'IFEQ' -> true;
+ Arg2 when Test == 'IFNEQ' -> false;
+ _ when Test == 'IFNEQ' -> true;
+ _ -> false
+ end,
+ Comment = io_lib:format("# Result of test: ~s (~s, ~s) -> ~w",
+ [atom_to_list(Test),Arg1,Arg2,Result]),
+ {Result,Comment,Rest2}.
+
+%% extract an argument
+get_arg([$ |Rest], Vars, Stop, Acc) ->
+ get_arg(Rest, Vars, Stop, Acc);
+get_arg([$(|Rest], Vars, Stop, _) ->
+ get_arg(Rest, Vars, Stop, []);
+get_arg([Stop|Rest], Vars, Stop, Acc) ->
+ Arg = lists:reverse(Acc),
+ Subst = subst(Arg, Vars),
+ {Subst,Rest};
+get_arg([C|Rest], Vars, Stop, Acc) ->
+ get_arg(Rest, Vars, Stop, [C|Acc]).
+
+%% keep only the true or false conditional clause
+extract_clause(true, Rest) ->
+ extract_clause(true, Rest, []);
+extract_clause(false, Rest) ->
+ Rest1 = discard_clause(Rest), % discard true clause
+ extract_clause(false, Rest1, []).
+
+%% true clause buffered, done
+extract_clause(true, [$@,$E,$L,$S,$E,$@|Rest], Acc) ->
+ Rest1 = discard_clause(Rest), % discard false clause
+ lists:reverse(Acc, Rest1);
+%% buffering of false clause starts now
+extract_clause(false, [$@,$E,$L,$S,$E,$@|Rest], _Acc) ->
+ extract_clause(false, Rest, []);
+%% true clause buffered, done
+extract_clause(true, [$@,$E,$N,$D,$I,$F,$@|Rest], Acc) ->
+ lists:reverse(Acc, Rest);
+%% false clause buffered, done
+extract_clause(false, [$@,$E,$N,$D,$I,$F,$@|Rest], Acc) ->
+ lists:reverse(Acc, Rest);
+%% keep buffering
+extract_clause(Bool, [C|Rest], Acc) ->
+ extract_clause(Bool, Rest, [C|Acc]);
+%% parse error
+extract_clause(_, [], Acc) ->
+ lists:reverse(Acc).
+
+discard_clause([$@,$E,$L,$S,$E,$@|Rest]) ->
+ Rest;
+discard_clause([$@,$E,$N,$D,$I,$F,$@|Rest]) ->
+ Rest;
+discard_clause([_C|Rest]) ->
+ discard_clause(Rest);
+discard_clause([]) -> % parse error
+ [].
+
+
+print_data(Port) ->
+ receive
+ {Port, {data, Bytes}} ->
+ io:put_chars(Bytes),
+ print_data(Port);
+ {Port, eof} ->
+ Port ! {self(), close},
+ receive
+ {Port, closed} ->
+ true
+ end,
+ receive
+ {'EXIT', Port, _} ->
+ ok
+ after 1 -> % force context switch
+ ok
+ end
+ end.
+
+maybe_atom_to_list(To_list) when is_list(To_list) ->
+ To_list;
+maybe_atom_to_list(To_list) when is_atom(To_list)->
+ atom_to_list(To_list).
+
diff --git a/lib/test_server/src/ts_make.erl b/lib/test_server/src/ts_make.erl
new file mode 100644
index 0000000000..3df66111a3
--- /dev/null
+++ b/lib/test_server/src/ts_make.erl
@@ -0,0 +1,103 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(ts_make).
+
+-export([make/1,make/3,unmake/1]).
+
+-include("test_server.hrl").
+
+%% Functions to be called from make test cases.
+
+make(Config) when is_list(Config) ->
+ DataDir = ?config(data_dir, Config),
+ Makefile = ?config(makefile, Config),
+ Make = ?config(make_command, Config),
+ case make(Make, DataDir, Makefile) of
+ ok -> ok;
+ {error,Reason} -> ?t:fail({make_failed,Reason})
+ end.
+
+unmake(Config) when is_list(Config) ->
+ ok.
+
+%% Runs `make' in the given directory.
+%% Result: ok | {error, Reason}
+
+make(Make, Dir, Makefile) ->
+ {RunFile, RunCmd, Script} = run_make_script(os:type(), Make, Dir, Makefile),
+ case file:write_file(RunFile, Script) of
+ ok ->
+ Log = filename:join(Dir, "make.log"),
+ file:delete(Log),
+ Port = open_port({spawn, RunCmd}, [eof,stream,in,stderr_to_stdout]),
+ case get_port_data(Port, [], false) of
+ "*ok*" ++ _ -> ok;
+ "*error*" ++ _ -> {error, make};
+ Other ->{error,{make,Other}}
+ end;
+ Error -> Error
+ end.
+
+get_port_data(Port, Last0, Complete0) ->
+ receive
+ {Port,{data,Bytes}} ->
+ {Last, Complete} = update_last(Bytes, Last0, Complete0),
+ get_port_data(Port, Last, Complete);
+ {Port, eof} ->
+ Result = update_last(eof, Last0, Complete0),
+ unlink(Port),
+ exit(Port, die),
+ Result
+ end.
+
+update_last([C|Rest], Line, true) ->
+ io:put_chars(Line),
+ io:nl(),
+ update_last([C|Rest], [], false);
+update_last([$\r|Rest], Result, Complete) ->
+ update_last(Rest, Result, Complete);
+update_last([$\n|Rest], Result, _Complete) ->
+ update_last(Rest, lists:reverse(Result), true);
+update_last([C|Rest], Result, Complete) ->
+ update_last(Rest, [C|Result], Complete);
+update_last([], Result, Complete) ->
+ {Result, Complete};
+update_last(eof, Result, _) ->
+ Result.
+
+run_make_script({win32, _}, Make, Dir, Makefile) ->
+ {"run_make.bat",
+ ".\\run_make",
+ ["@echo off\r\n",
+ "cd ", filename:nativename(Dir), "\r\n",
+ Make, " -f ", Makefile, " \r\n",
+ "if errorlevel 1 echo *error*\r\n",
+ "if not errorlevel 1 echo *ok*\r\n"]};
+run_make_script({unix, _}, Make, Dir, Makefile) ->
+ {"run_make",
+ "/bin/sh ./run_make",
+ ["#!/bin/sh\n",
+ "cd ", Dir, "\n",
+ Make, " -f ", Makefile, " 2>&1\n",
+ "case $? in\n",
+ " 0) echo '*ok*';;\n",
+ " *) echo '*error*';;\n",
+ "esac\n"]};
+run_make_script(_Other, _Make, _Dir, _Makefile) ->
+ exit(dont_know_how_to_make_script_on_this_platform).
diff --git a/lib/test_server/src/ts_reports.erl b/lib/test_server/src/ts_reports.erl
new file mode 100644
index 0000000000..b41291d342
--- /dev/null
+++ b/lib/test_server/src/ts_reports.erl
@@ -0,0 +1,543 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%% Purpose : Produces reports in HTML from the outcome of test suite runs.
+
+-module(ts_reports).
+
+-export([make_index/0, make_master_index/2, make_progress_index/2]).
+-export([count_cases/1, year/0, current_time/0]).
+
+-include_lib("kernel/include/file.hrl").
+-include("ts.hrl").
+
+-import(filename, [basename/1, rootname/1]).
+-import(ts_lib, [error/1]).
+
+
+%% Make master index page which points out index pages for all platforms.
+
+make_master_index(Dir, Vars) ->
+ IndexName = filename:join(Dir, "index.html"),
+ {ok, Index0} = make_master_index1(directories(Dir), master_header(Vars)),
+ Index = [Index0|master_footer()],
+ io:put_chars("Updating " ++ IndexName ++ "... "),
+ ok = ts_lib:force_write_file(IndexName, Index),
+ io:put_chars("done\n").
+
+make_master_index1([Dir|Rest], Result) ->
+ NewResult =
+ case catch read_variables(Dir) of
+ {'EXIT',{{bad_installation,Reason},_}} ->
+ io:put_chars("Failed to read " ++ filename:join(Dir,?variables)++
+ ": " ++ Reason ++ " - Ignoring this directory\n"),
+ Result;
+ Vars ->
+ Platform = ts_lib:var(platform_label, Vars),
+ case make_index(Dir, Vars, false) of
+ {ok, Summary} ->
+ make_master_index(Platform, Dir, Summary, Result);
+ {error, _} ->
+ Result
+ end
+ end,
+ make_master_index1(Rest, NewResult);
+make_master_index1([], Result) ->
+ {ok, Result}.
+
+make_progress_index(Dir, Vars) ->
+ IndexName = filename:join(Dir, "index.html"),
+ io:put_chars("Updating " ++ IndexName ++ "... "),
+ Index0=progress_header(Vars),
+ ts_lib:force_delete(IndexName),
+ Dirs=find_progress_runs(Dir),
+ Index1=[Index0|make_progress_links(Dirs, [])],
+ IndexF=[Index1|progress_footer()],
+ ok = ts_lib:force_write_file(IndexName, IndexF),
+ io:put_chars("done\n").
+
+find_progress_runs(Dir) ->
+ case file:list_dir(Dir) of
+ {ok, Dirs0} ->
+ Dirs1= [filename:join(Dir,X) || X <- Dirs0,
+ filelib:is_dir(filename:join(Dir,X))],
+ lists:sort(Dirs1);
+ _ ->
+ []
+ end.
+
+name_from_vars(Dir, Platform) ->
+ VarFile=filename:join([Dir, Platform, "variables"]),
+ case file:consult(VarFile) of
+ {ok, Vars} ->
+ ts_lib:var(platform_id, Vars);
+ _Other ->
+ Platform
+ end.
+
+make_progress_links([], Acc) ->
+ Acc;
+make_progress_links([RDir|Rest], Acc) ->
+ Dir=filename:basename(RDir),
+ Platforms=[filename:basename(X) ||
+ X <- find_progress_runs(RDir)],
+ PlatformLinks=["<A HREF=\""++filename:join([Dir,X,"index.html"])
+ ++"\">"++name_from_vars(RDir, X)++"</A><BR>" ||
+ X <- Platforms],
+ LinkName=Dir++"/index.html",
+ Link =
+ [
+ "<TR valign=top>\n",
+ "<TD><A HREF=\"", LinkName, "\">", Dir, "</A></TD>", "\n",
+ "<TD>", PlatformLinks, "</TD>", "\n"
+ ],
+ make_progress_links(Rest, [Link|Acc]).
+
+read_variables(Dir) ->
+ case file:consult(filename:join(Dir, ?variables)) of
+ {ok, Vars} -> Vars;
+ {error, Reason} ->
+ erlang:error({bad_installation,file:format_error(Reason)}, [Dir])
+ end.
+
+make_master_index(Platform, Dirname, {Succ, Fail, UserSkip,AutoSkip}, Result) ->
+ Link = filename:join(filename:basename(Dirname), "index.html"),
+ FailStr =
+ if Fail > 0 ->
+ ["<FONT color=\"red\">",
+ integer_to_list(Fail),"</FONT>"];
+ true ->
+ integer_to_list(Fail)
+ end,
+ AutoSkipStr =
+ if AutoSkip > 0 ->
+ ["<FONT color=\"brown\">",
+ integer_to_list(AutoSkip),"</FONT>"];
+ true -> integer_to_list(AutoSkip)
+ end,
+ [Result,
+ "<TR valign=top>\n",
+ "<TD><A HREF=\"", Link, "\">", Platform, "</A></TD>", "\n",
+ make_row(integer_to_list(Succ), false),
+ make_row(FailStr, false),
+ make_row(integer_to_list(UserSkip), false),
+ make_row(AutoSkipStr, false),
+ "</TR>\n"].
+
+%% Make index page which points out individual test suites for a single platform.
+
+make_index() ->
+ {ok, Pwd} = file:get_cwd(),
+ Vars = read_variables(Pwd),
+ make_index(Pwd, Vars, true).
+
+make_index(Dir, Vars, IncludeLast) ->
+ IndexName = filename:absname("index.html", Dir),
+ io:put_chars("Updating " ++ IndexName ++ "... "),
+ case catch make_index1(Dir, IndexName, Vars, IncludeLast) of
+ {'EXIT', Reason} ->
+ io:put_chars("CRASHED!\n"),
+ io:format("~p~n", [Reason]),
+ {error, Reason};
+ {error, Reason} ->
+ io:put_chars("FAILED\n"),
+ io:format("~p~n", [Reason]),
+ {error, Reason};
+ {ok, Summary} ->
+ io:put_chars("done\n"),
+ {ok, Summary};
+ Err ->
+ io:format("Unknown internal error. Please report.\n(Err: ~p, ID: 1)",
+ [Err]),
+ {error, Err}
+ end.
+
+make_index1(Dir, IndexName, Vars, IncludeLast) ->
+ Logs0 = ts_lib:interesting_logs(Dir),
+ Logs =
+ case IncludeLast of
+ true -> add_last_name(Logs0);
+ false -> Logs0
+ end,
+ {ok, {Index0, Summary}} = make_index(Logs, header(Vars), 0, 0, 0, 0, 0),
+ Index = [Index0|footer()],
+ case ts_lib:force_write_file(IndexName, Index) of
+ ok ->
+ {ok, Summary};
+ {error, Reason} ->
+ error({index_write_error, Reason})
+ end.
+
+make_index([Name|Rest], Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt) ->
+ case ts_lib:last_test(Name) of
+ false ->
+ %% Silently skip.
+ make_index(Rest, Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt);
+ Last ->
+ case count_cases(Last) of
+ {Succ, Fail, USkip, ASkip} ->
+ Cov =
+ case file:read_file(filename:join(Last,?cover_total)) of
+ {ok,Bin} ->
+ TotCoverage = binary_to_term(Bin),
+ io_lib:format("~w %",[TotCoverage]);
+ _error ->
+ ""
+ end,
+ Link = filename:join(basename(Name), basename(Last)),
+ JustTheName = rootname(basename(Name)),
+ NotBuilt = not_built(JustTheName),
+ NewResult = [Result, make_index1(JustTheName,
+ Link, Succ, Fail, USkip, ASkip,
+ NotBuilt, Cov, false)],
+ make_index(Rest, NewResult, TotSucc+Succ, TotFail+Fail,
+ UserSkip+USkip, AutoSkip+ASkip, TotNotBuilt+NotBuilt);
+ error ->
+ make_index(Rest, Result, TotSucc, TotFail, UserSkip, AutoSkip,
+ TotNotBuilt)
+ end
+ end;
+make_index([], Result, TotSucc, TotFail, UserSkip, AutoSkip, TotNotBuilt) ->
+ {ok, {[Result|make_index1("Total", no_link,
+ TotSucc, TotFail, UserSkip, AutoSkip,
+ TotNotBuilt, "", true)],
+ {TotSucc, TotFail, UserSkip, AutoSkip}}}.
+
+make_index1(SuiteName, Link, Success, Fail, UserSkip, AutoSkip, NotBuilt, Coverage, Bold) ->
+ Name = test_suite_name(SuiteName),
+ FailStr =
+ if Fail > 0 ->
+ ["<FONT color=\"red\">",
+ integer_to_list(Fail),"</FONT>"];
+ true ->
+ integer_to_list(Fail)
+ end,
+ AutoSkipStr =
+ if AutoSkip > 0 ->
+ ["<FONT color=\"brown\">",
+ integer_to_list(AutoSkip),"</FONT>"];
+ true -> integer_to_list(AutoSkip)
+ end,
+ ["<TR valign=top>\n",
+ "<TD>",
+ case Link of
+ no_link ->
+ ["<B>", Name|"</B>"];
+ _Other ->
+ CrashDumpName = SuiteName ++ "_erl_crash.dump",
+ CrashDumpLink =
+ case filelib:is_file(CrashDumpName) of
+ true ->
+ ["&nbsp;<A HREF=\"", CrashDumpName,
+ "\">(CrashDump)</A>"];
+ false ->
+ ""
+ end,
+ LogFile = filename:join(Link, ?suitelog_name ++ ".html"),
+ ["<A HREF=\"", LogFile, "\">", Name, "</A>\n", CrashDumpLink,
+ "</TD>\n"]
+ end,
+ make_row(integer_to_list(Success), Bold),
+ make_row(FailStr, Bold),
+ make_row(integer_to_list(UserSkip), Bold),
+ make_row(AutoSkipStr, Bold),
+ make_row(integer_to_list(NotBuilt), Bold),
+ make_row(Coverage, Bold),
+ "</TR>\n"].
+
+make_row(Row, true) ->
+ ["<TD ALIGN=right><B>", Row|"</B></TD>"];
+make_row(Row, false) ->
+ ["<TD ALIGN=right>", Row|"</TD>"].
+
+not_built(BaseName) ->
+ Dir = filename:join("..", BaseName++"_test"),
+ Erl = length(filelib:wildcard(filename:join(Dir,"*_SUITE.erl"))),
+ Beam = length(filelib:wildcard(filename:join(Dir,"*_SUITE.beam"))),
+ Erl-Beam.
+
+
+%% Add the log file directory for the very last test run (according to
+%% last_name).
+
+add_last_name(Logs) ->
+ case file:read_file("last_name") of
+ {ok, Bin} ->
+ Name = filename:dirname(lib:nonl(binary_to_list(Bin))),
+ case lists:member(Name, Logs) of
+ true -> Logs;
+ false -> [Name|Logs]
+ end;
+ _ ->
+ Logs
+ end.
+
+term_to_text(Term) ->
+ lists:flatten(io_lib:format("~p.\n", [Term])).
+
+test_suite_name(Name) ->
+ ts_lib:initial_capital(Name) ++ " suite".
+
+directories(Dir) ->
+ {ok, Files} = file:list_dir(Dir),
+ [filename:join(Dir, X) || X <- Files,
+ filelib:is_dir(filename:join(Dir, X))].
+
+
+%%% Headers and footers.
+
+header(Vars) ->
+ Platform = ts_lib:var(platform_id, Vars),
+ ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<HTML>\n",
+ "<HEAD>\n",
+ "<TITLE>Test Results for ", Platform, "</TITLE>\n",
+ "</HEAD>\n",
+
+ body_tag(),
+
+ "<!-- ---- DOCUMENT TITLE ---- -->\n",
+
+ "<CENTER>\n",
+ "<H1>Test Results for ", Platform, "</H1>\n",
+ "</CENTER>\n",
+
+ "<!-- ---- CONTENT ---- -->\n",
+ "<CENTER>\n",
+
+ "<TABLE border=3 cellpadding=5>\n",
+ "<th><B>Family</B></th>\n",
+ "<th>Successful</th>\n",
+ "<th>Failed</th>\n",
+ "<th>User Skipped</th>\n"
+ "<th>Auto Skipped</th>\n"
+ "<th>Missing Suites</th>\n"
+ "<th>Coverage</th>\n"
+ "\n"].
+
+footer() ->
+ ["</TABLE>\n"
+ "</CENTER>\n"
+ "<P><CENTER>\n"
+ "<HR>\n"
+ "<P><FONT SIZE=-1>\n"
+ "Copyright &copy; ", year(),
+ " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n"
+ "Updated: <!date>", current_time(), "<!/date><BR>\n"
+ "</FONT>\n"
+ "</CENTER>\n"
+ "</body>\n"
+ "</HTML>\n"].
+
+progress_header(Vars) ->
+ Release = ts_lib:var(erl_release, Vars),
+ ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<HTML>\n",
+ "<HEAD>\n",
+ "<TITLE>", Release, " Progress Test Results</TITLE>\n",
+ "</HEAD>\n",
+
+ body_tag(),
+
+ "<!-- ---- DOCUMENT TITLE ---- -->\n",
+
+ "<CENTER>\n",
+ "<H1>", Release, " Progress Test Results</H1>\n",
+ "<TABLE border=3 cellpadding=5>\n",
+ "<th><b>Test Run</b></th><th>Platforms</th>\n"].
+
+progress_footer() ->
+ ["</TABLE>\n",
+ "</CENTER>\n",
+ "<P><CENTER>\n",
+ "<HR>\n",
+ "<P><FONT SIZE=-1>\n",
+ "Copyright &copy; ", year(),
+ " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n",
+ "Updated: <!date>", current_time(), "<!/date><BR>\n",
+ "</FONT>\n",
+ "</CENTER>\n",
+ "</body>\n",
+ "</HTML>\n"].
+
+master_header(Vars) ->
+ Release = ts_lib:var(erl_release, Vars),
+ Vsn = erlang:system_info(version),
+ ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n"
+ "<!-- autogenerated by '"++atom_to_list(?MODULE)++"'. -->\n"
+ "<HTML>\n",
+ "<HEAD>\n",
+ "<TITLE>", Release, " Test Results (", Vsn, ")</TITLE>\n",
+ "</HEAD>\n",
+
+ body_tag(),
+
+ "<!-- ---- DOCUMENT TITLE ---- -->\n",
+
+ "<CENTER>\n",
+ "<H1>", Release, " Test Results (", Vsn, ")</H1>\n",
+ "</CENTER>\n",
+
+ "<!-- ---- CONTENT ---- -->\n",
+
+ "<CENTER>\n",
+
+ "<TABLE border=3 cellpadding=5>\n",
+ "<th><b>Platform</b></th>\n",
+ "<th>Successful</th>\n",
+ "<th>Failed</th>\n",
+ "<th>User Skipped</th>\n"
+ "<th>Auto Skipped</th>\n"
+ "\n"].
+
+master_footer() ->
+ ["</TABLE>\n",
+ "</CENTER>\n",
+ "<P><CENTER>\n",
+ "<HR>\n",
+ "<P><FONT SIZE=-1>\n",
+ "Copyright &copy; ", year(),
+ " <A HREF=\"http://erlang.ericsson.se\">Open Telecom Platform</A><BR>\n",
+ "Updated: <!date>", current_time(), "<!/date><BR>\n",
+ "</FONT>\n",
+ "</CENTER>\n",
+ "</body>\n",
+ "</HTML>\n"].
+
+body_tag() ->
+ "<body bgcolor=\"#FFFFFF\" text=\"#000000\" link=\"#0000FF\""
+ "vlink=\"#800080\" alink=\"#FF0000\">".
+
+year() ->
+ {Y, _, _} = date(),
+ integer_to_list(Y).
+
+current_time() ->
+ {{Y, Mon, D}, {H, Min, S}} = calendar:local_time(),
+ Weekday = weekday(calendar:day_of_the_week(Y, Mon, D)),
+ lists:flatten(io_lib:format("~s ~s ~p ~2.2.0w:~2.2.0w:~2.2.0w ~w",
+ [Weekday, month(Mon), D, H, Min, S, Y])).
+
+weekday(1) -> "Mon";
+weekday(2) -> "Tue";
+weekday(3) -> "Wed";
+weekday(4) -> "Thu";
+weekday(5) -> "Fri";
+weekday(6) -> "Sat";
+weekday(7) -> "Sun".
+
+month(1) -> "Jan";
+month(2) -> "Feb";
+month(3) -> "Mar";
+month(4) -> "Apr";
+month(5) -> "May";
+month(6) -> "Jun";
+month(7) -> "Jul";
+month(8) -> "Aug";
+month(9) -> "Sep";
+month(10) -> "Oct";
+month(11) -> "Nov";
+month(12) -> "Dec".
+
+%% Count test cases in the given directory (a directory of the type
+%% run.1997-08-04_09.58.52).
+
+count_cases(Dir) ->
+ SumFile = filename:join(Dir, ?run_summary),
+ case read_summary(SumFile, [summary]) of
+ {ok, [{Succ,Fail,Skip}]} ->
+ {Succ,Fail,Skip,0};
+ {ok, [Summary]} ->
+ Summary;
+ {error, _} ->
+ LogFile = filename:join(Dir, ?suitelog_name),
+ case file:read_file(LogFile) of
+ {ok, Bin} ->
+ Summary = count_cases1(binary_to_list(Bin), {0, 0, 0, 0}),
+ write_summary(SumFile, Summary),
+ Summary;
+ {error, _Reason} ->
+ io:format("\nFailed to read ~p (skipped)\n", [LogFile]),
+ error
+ end
+ end.
+
+write_summary(Name, Summary) ->
+ File = [term_to_text({summary, Summary})],
+ ts_lib:force_write_file(Name, File).
+
+% XXX: This function doesn't do what the writer expect. It can't handle
+% the case if there are several different keys and I had to add a special
+% case for the empty file. The caller also expect just one tuple as
+% a result so this function is written way to general for no reason.
+% But it works sort of. /kgb
+
+read_summary(Name, Keys) ->
+ case file:consult(Name) of
+ {ok, []} ->
+ {error, "Empty summary file"};
+ {ok, Terms} ->
+ {ok, lists:map(fun(Key) -> {value, {_, Value}} =
+ lists:keysearch(Key, 1, Terms),
+ Value end,
+ Keys)};
+ {error, Reason} ->
+ {error, Reason}
+ end.
+
+count_cases1("=failed" ++ Rest, {Success, _Fail, UserSkip,AutoSkip}) ->
+ {NextLine, Count} = get_number(Rest),
+ count_cases1(NextLine, {Success, Count, UserSkip,AutoSkip});
+count_cases1("=successful" ++ Rest, {_Success, Fail, UserSkip,AutoSkip}) ->
+ {NextLine, Count} = get_number(Rest),
+ count_cases1(NextLine, {Count, Fail, UserSkip,AutoSkip});
+count_cases1("=skipped" ++ Rest, {Success, Fail, _UserSkip,AutoSkip}) ->
+ {NextLine, Count} = get_number(Rest),
+ count_cases1(NextLine, {Success, Fail, Count,AutoSkip});
+count_cases1("=user_skipped" ++ Rest, {Success, Fail, _UserSkip,AutoSkip}) ->
+ {NextLine, Count} = get_number(Rest),
+ count_cases1(NextLine, {Success, Fail, Count,AutoSkip});
+count_cases1("=auto_skipped" ++ Rest, {Success, Fail, UserSkip,_AutoSkip}) ->
+ {NextLine, Count} = get_number(Rest),
+ count_cases1(NextLine, {Success, Fail, UserSkip,Count});
+count_cases1([], Counters) ->
+ Counters;
+count_cases1(Other, Counters) ->
+ count_cases1(skip_to_nl(Other), Counters).
+
+get_number([$\s|Rest]) ->
+ get_number(Rest);
+get_number([Digit|Rest]) when $0 =< Digit, Digit =< $9 ->
+ get_number(Rest, Digit-$0).
+
+get_number([Digit|Rest], Acc) when $0 =< Digit, Digit =< $9 ->
+ get_number(Rest, Acc*10+Digit-$0);
+get_number([$\n|Rest], Acc) ->
+ {Rest, Acc};
+get_number([_|Rest], Acc) ->
+ get_number(Rest, Acc).
+
+skip_to_nl([$\n|Rest]) ->
+ Rest;
+skip_to_nl([_|Rest]) ->
+ skip_to_nl(Rest);
+skip_to_nl([]) ->
+ [].
diff --git a/lib/test_server/src/ts_run.erl b/lib/test_server/src/ts_run.erl
new file mode 100644
index 0000000000..3461e1383c
--- /dev/null
+++ b/lib/test_server/src/ts_run.erl
@@ -0,0 +1,746 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%% Purpose : Supervises running of test cases.
+
+-module(ts_run).
+
+-export([run/4]).
+
+-define(DEFAULT_MAKE_TIMETRAP_MINUTES, 60).
+-define(DEFAULT_UNMAKE_TIMETRAP_MINUTES, 15).
+
+-include("ts.hrl").
+
+-import(lists, [map/2,member/2,filter/2,reverse/1]).
+
+-record(state,
+ {file, % File given.
+ mod, % Module to run.
+ test_server_args, % Arguments to test server.
+ command, % Command to run.
+ test_dir, % Directory for test suite.
+ makefiles, % List of all makefiles.
+ makefile, % Current makefile.
+ batch, % Are we running in batch mode?
+ data_wc, % Wildcard for data dirs.
+ topcase, % Top case specification.
+ all % Set if we have all_SUITE_data
+ }).
+
+-define(tracefile,"traceinfo").
+
+%% Options is a slightly modified version of the options given to
+%% ts:run. Vars0 are from the variables file.
+run(File, Args0, Options, Vars0) ->
+ Vars=
+ case lists:keysearch(vars, 1, Options) of
+ {value, {vars, Vars1}} ->
+ Vars1++Vars0;
+ _ ->
+ Vars0
+ end,
+ {Batch,Runner} =
+ case {member(interactive, Options), member(batch, Options)} of
+ {false, true} ->
+ {true, fun run_batch/3};
+ _ ->
+ {false, fun run_interactive/3}
+ end,
+ HandleTopcase = case member(keep_topcase, Options) of
+ true -> [fun copy_topcase/3];
+ false -> [fun remove_original_topcase/3,
+ fun init_topcase/3]
+ end,
+ MakefileHooks = [fun make_make/3,
+ fun add_make_testcase/3],
+ MakeLoop = fun(V, Sp, St) -> make_loop(MakefileHooks, V, Sp, St) end,
+ Hooks = [fun init_state/3,
+ fun read_spec_file/3] ++
+ HandleTopcase ++
+ [fun run_preinits/3,
+ fun find_makefiles/3,
+ MakeLoop,
+ fun make_test_suite/3,
+ fun add_topcase_to_spec/3,
+ fun write_spec_file/3,
+ fun make_command/3,
+ Runner],
+ Args = make_test_server_args(Args0,Options,Vars),
+ St = #state{file=File,test_server_args=Args,batch=Batch},
+ R = execute(Hooks, Vars, [], St),
+ case Batch of
+ true -> ts_reports:make_index();
+ false -> ok % ts_reports:make_index() is run on the test_server node
+ end,
+ case R of
+ {ok,_,_,_} -> ok;
+ Error -> Error
+ end.
+
+make_loop(Hooks, Vars0, Spec0, St0) ->
+ case St0#state.makefiles of
+ [Makefile|Rest] ->
+ case execute(Hooks, Vars0, Spec0, St0#state{makefile=Makefile}) of
+ {error, Reason} ->
+ {error, Reason};
+ {ok, Vars, Spec, St} ->
+ make_loop(Hooks, Vars, Spec, St#state{makefiles=Rest})
+ end;
+ [] ->
+ {ok, Vars0, Spec0, St0}
+ end.
+
+execute([Hook|Rest], Vars0, Spec0, St0) ->
+ case Hook(Vars0, Spec0, St0) of
+ ok ->
+ execute(Rest, Vars0, Spec0, St0);
+ {ok, Vars, Spec, St} ->
+ execute(Rest, Vars, Spec, St);
+ Error ->
+ Error
+ end;
+execute([], Vars, Spec, St) ->
+ {ok, Vars, Spec, St}.
+
+%%
+%% Deletes File from Files when File is on the form .../<SUITE>_data/<file>
+%% when all of <SUITE> has been skipped in Spec, i.e. there
+%% exists a {skip, {<SUITE>, _}} tuple in Spec.
+%%
+del_skipped_suite_data_dir(Files, Spec) ->
+ SkipDirNames = lists:foldl(fun ({skip, {SS, _C}}, SSs) ->
+ [atom_to_list(SS) ++ "_data" | SSs];
+ (_, SSs) ->
+ SSs
+ end,
+ [],
+ Spec),
+ filter(fun (File) ->
+ not member(filename:basename(filename:dirname(File)),
+ SkipDirNames)
+ end,
+ Files).
+
+%% Initialize our internal state.
+
+init_state(Vars, [], St0) ->
+ {FileBase,Wc0,Mod} =
+ case St0#state.file of
+ {Fil,Mod0} -> {Fil, atom_to_list(Mod0) ++ "*_data",Mod0};
+ Fil -> {Fil,"*_SUITE_data",[]}
+ end,
+ {ok,Cwd} = file:get_cwd(),
+ TestDir = filename:join(filename:dirname(Cwd), FileBase++"_test"),
+ case filelib:is_dir(TestDir) of
+ true ->
+ Wc = filename:join(TestDir, Wc0),
+ {ok,Vars,[],St0#state{file=FileBase,mod=Mod,
+ test_dir=TestDir,data_wc=Wc}};
+ false ->
+ {error,{no_test_directory,TestDir}}
+ end.
+
+%% Read the spec file for the test suite.
+
+read_spec_file(Vars, _, St) ->
+ TestDir = St#state.test_dir,
+ File = St#state.file,
+ {SpecFile,Res} = get_spec_filename(Vars, TestDir, File),
+ case Res of
+ {ok,Spec} ->
+ {ok,Vars,Spec,St};
+ {error,Atom} when is_atom(Atom) ->
+ {error,{no_spec,SpecFile}};
+ {error,Reason} ->
+ {error,{bad_spec,lists:flatten(file:format_error(Reason))}}
+ end.
+
+get_spec_filename(Vars, TestDir, File) ->
+ DynSpec = filename:join(TestDir, File ++ ".dynspec"),
+ case filelib:is_file(DynSpec) of
+ true ->
+ Bs0 = erl_eval:new_bindings(),
+ Bs1 = erl_eval:add_binding('Target', ts_lib:var(target, Vars), Bs0),
+ Bs2 = erl_eval:add_binding('Os', ts_lib:var(os, Vars), Bs1),
+ TCCStr = ts_lib:var(test_c_compiler, Vars),
+ TCC = try
+ {ok, Toks, _} = erl_scan:string(TCCStr ++ "."),
+ {ok, Tcc} = erl_parse:parse_term(Toks),
+ Tcc
+ catch
+ _:_ -> undefined
+ end,
+ Bs = erl_eval:add_binding('TestCCompiler', TCC, Bs2),
+ {DynSpec,file:script(DynSpec, Bs)};
+ false ->
+ SpecFile = get_spec_filename_1(Vars, TestDir, File),
+ {SpecFile,file:consult(SpecFile)}
+ end.
+
+get_spec_filename_1(Vars, TestDir, File) ->
+ case ts_lib:var(os, Vars) of
+ "VxWorks" ->
+ check_spec_filename(TestDir, File, ".spec.vxworks");
+ "OSE" ->
+ check_spec_filename(TestDir, File, ".spec.ose");
+ "Windows"++_ ->
+ check_spec_filename(TestDir, File, ".spec.win");
+ _Other ->
+ filename:join(TestDir, File ++ ".spec")
+ end.
+
+check_spec_filename(TestDir, File, Ext) ->
+ Spec = filename:join(TestDir, File ++ Ext),
+ case filelib:is_file(Spec) of
+ true -> Spec;
+ false -> filename:join(TestDir, File ++ ".spec")
+ end.
+
+%% Remove the top case from the spec file. We will add our own
+%% top case later.
+
+remove_original_topcase(Vars, Spec, St) ->
+ {ok,Vars,filter(fun ({topcase,_}) -> false;
+ (_Other) -> true end, Spec),St}.
+
+%% Initialize our new top case. We'll keep in it the state to be
+%% able to add more to it.
+
+init_topcase(Vars, Spec, St) ->
+ TestDir = St#state.test_dir,
+ TopCase =
+ case St#state.mod of
+ Mod when is_atom(Mod) ->
+ ModStr = atom_to_list(Mod),
+ case filelib:is_file(filename:join(TestDir,ModStr++".erl")) of
+ true -> [{Mod,all}];
+ false ->
+ Wc = filename:join(TestDir, ModStr ++ "*_SUITE.erl"),
+ [{list_to_atom(filename:basename(M, ".erl")),all} ||
+ M <- filelib:wildcard(Wc)]
+ end;
+ _Other ->
+ %% Here we used to return {dir,TestDir}. Now we instead
+ %% list all suites in TestDir, so we can add make testcases
+ %% around it later (see add_make_testcase) without getting
+ %% duplicates of the suite. (test_server_ctrl does no longer
+ %% check for duplicates of testcases)
+ Wc = filename:join(TestDir, "*_SUITE.erl"),
+ [{list_to_atom(filename:basename(M, ".erl")),all} ||
+ M <- filelib:wildcard(Wc)]
+ end,
+ {ok,Vars,Spec,St#state{topcase=TopCase}}.
+
+%% Or if option keep_topcase was given, eh... keep the topcase
+copy_topcase(Vars, Spec, St) ->
+ {value,{topcase,Tc}} = lists:keysearch(topcase,1,Spec),
+ {ok, Vars, lists:keydelete(topcase,1,Spec),St#state{topcase=Tc}}.
+
+
+%% Run any "Makefile.first" files first.
+%% XXX We should fake a failing test case if the make fails.
+
+run_preinits(Vars, Spec, St) ->
+ Wc = filename:join(St#state.data_wc, "Makefile.first"),
+ run_pre_makefiles(del_skipped_suite_data_dir(filelib:wildcard(Wc), Spec),
+ Vars, Spec, St),
+ {ok,Vars,Spec,St}.
+
+run_pre_makefiles([Makefile|Ms], Vars0, Spec0, St0) ->
+ Hooks = [fun run_pre_makefile/3],
+ case execute(Hooks, Vars0, Spec0, St0#state{makefile=Makefile}) of
+ {error,_Reason}=Error -> Error;
+ {ok,Vars,Spec,St} -> run_pre_makefiles(Ms, Vars, Spec, St)
+ end;
+run_pre_makefiles([], Vars, Spec, St) -> {ok,Vars,Spec,St}.
+
+run_pre_makefile(Vars, Spec, St) ->
+ Makefile = St#state.makefile,
+ Shortname = filename:basename(Makefile),
+ DataDir = filename:dirname(Makefile),
+ Make = ts_lib:var(make_command, Vars),
+ case ts_make:make(Make,DataDir, Shortname) of
+ ok -> {ok,Vars,Spec,St};
+ {error,_Reason}=Error -> Error
+ end.
+
+%% Search for `Makefile.src' in each *_SUITE_data directory.
+
+find_makefiles(Vars, Spec, St) ->
+ Wc = filename:join(St#state.data_wc, "Makefile.src"),
+ Makefiles = reverse(del_skipped_suite_data_dir(filelib:wildcard(Wc), Spec)),
+ {ok,Vars,Spec,St#state{makefiles=Makefiles}}.
+
+%% Create "Makefile" from "Makefile.src".
+
+make_make(Vars, Spec, State) ->
+ Src = State#state.makefile,
+ Dest = filename:rootname(Src),
+ ts_lib:progress(Vars, 1, "Making ~s...\n", [Dest]),
+ case ts_lib:subst_file(Src, Dest, Vars) of
+ ok ->
+ {ok, Vars, Spec, State#state{makefile=Dest}};
+ {error, Reason} ->
+ {error, {Src, Reason}}
+ end.
+
+%% Add a testcase which will do the making of the stuff in the data directory.
+
+add_make_testcase(Vars, Spec, St) ->
+ Makefile = St#state.makefile,
+ Dir = filename:dirname(Makefile),
+ case ts_lib:var(os, Vars) of
+ "OSE" ->
+ %% For OSE, C code in datadir must be linked in the image file,
+ %% and erlang code is sent as binaries from test_server_ctrl
+ %% Making erlang code here because the Makefile.src probably won't
+ %% work.
+ Erl_flags=[{i, "../../test_server"}|ts_lib:var(erl_flags,Vars)],
+ {ok, Cwd} = file:get_cwd(),
+ ok = file:set_cwd(Dir),
+ Result = (catch make:all(Erl_flags)),
+ ok = file:set_cwd(Cwd),
+ case Result of
+ up_to_date -> {ok, Vars, Spec, St};
+ _error -> {error, {erlang_make_failed,Dir}}
+ end;
+ _ ->
+ Shortname = filename:basename(Makefile),
+ Suite = filename:basename(Dir, "_data"),
+ Config = [{data_dir,Dir},{makefile,Shortname}],
+ MakeModule = Suite ++ "_make",
+ MakeModuleSrc = filename:join(filename:dirname(Dir),
+ MakeModule ++ ".erl"),
+ MakeMod = list_to_atom(MakeModule),
+ case filelib:is_file(MakeModuleSrc) of
+ true -> ok;
+ false -> generate_make_module(ts_lib:var(make_command, Vars),
+ MakeModuleSrc,
+ MakeModule)
+ end,
+ case Suite of
+ "all_SUITE" ->
+ {ok,Vars,Spec,St#state{all={MakeMod,Config}}};
+ _ ->
+ %% Avoid duplicates of testcases. There is no longer
+ %% a check for this in test_server_ctrl.
+ TestCase = {list_to_atom(Suite),all},
+ TopCase0 = case St#state.topcase of
+ List when is_list(List) ->
+ List -- [TestCase];
+ Top ->
+ [Top] -- [TestCase]
+ end,
+ TopCase = [{make,{MakeMod,make,[Config]},
+ TestCase,
+ {MakeMod,unmake,[Config]}}|TopCase0],
+ {ok,Vars,Spec,St#state{topcase=TopCase}}
+ end
+ end.
+
+generate_make_module(MakeCmd, Name, ModuleString) ->
+ {ok,Host} = inet:gethostname(),
+ file:write_file(Name,
+ ["-module(",ModuleString,").\n",
+ "\n",
+ "-export([make/1,unmake/1]).\n",
+ "\n",
+ "make(Config) when is_list(Config) ->\n",
+ " Mins = " ++ integer_to_list(?DEFAULT_MAKE_TIMETRAP_MINUTES) ++ ",\n"
+ " test_server:format(\"=== Setting timetrap to ~p minutes ===~n\", [Mins]),\n"
+ " TimeTrap = test_server:timetrap(test_server:minutes(Mins)),\n"
+ " Res = ts_make:make([{make_command, \""++MakeCmd++"\"},{cross_node,\'ts@" ++ Host ++ "\'}|Config]),\n",
+ " test_server:timetrap_cancel(TimeTrap),\n"
+ " Res.\n"
+ "\n",
+ "unmake(Config) when is_list(Config) ->\n",
+ " Mins = " ++ integer_to_list(?DEFAULT_UNMAKE_TIMETRAP_MINUTES) ++ ",\n"
+ " test_server:format(\"=== Setting timetrap to ~p minutes ===~n\", [Mins]),\n"
+ " TimeTrap = test_server:timetrap(test_server:minutes(Mins)),\n"
+ " Res = ts_make:unmake([{make_command, \""++MakeCmd++"\"}|Config]),\n"
+ " test_server:timetrap_cancel(TimeTrap),\n"
+ " Res.\n"
+ "\n"]).
+
+
+make_test_suite(Vars, _Spec, State) ->
+ TestDir = State#state.test_dir,
+
+ Erl_flags=[{i, "../test_server"}|ts_lib:var(erl_flags,Vars)],
+
+ case code:is_loaded(test_server_line) of
+ false -> code:load_file(test_server_line);
+ _ -> ok
+ end,
+
+ {ok, Cwd} = file:get_cwd(),
+ ok = file:set_cwd(TestDir),
+ Result = (catch make:all(Erl_flags)),
+ ok = file:set_cwd(Cwd),
+ case Result of
+ up_to_date ->
+ ok;
+ {'EXIT', Reason} ->
+ %% If I return an error here, the test will be stopped
+ %% and it will not show up in the top index page. Instead
+ %% I return ok - the test will run for all existing suites.
+ %% It might be that there are old suites that are run, but
+ %% at least one suite is missing, and that is reported on the
+ %% top index page.
+ io:format("~s: {error,{make_crashed,~p}\n",
+ [State#state.file,Reason]),
+ ok;
+ error ->
+ %% See comment above
+ io:format("~s: {error,make_of_test_suite_failed}\n",
+ [State#state.file]),
+ ok
+ end.
+
+%% Add topcase to spec.
+
+add_topcase_to_spec(Vars, Spec, St) ->
+ Tc = case St#state.all of
+ {MakeMod,Config} ->
+ [{make,{MakeMod,make,[Config]},
+ St#state.topcase,
+ {MakeMod,unmake,[Config]}}];
+ undefined -> St#state.topcase
+ end,
+ {ok,Vars,Spec++[{topcase,Tc}],St}.
+
+%% Writes the (possibly transformed) spec file.
+
+write_spec_file(Vars, Spec, _State) ->
+ F = fun(Term) -> io_lib:format("~p.~n", [Term]) end,
+ SpecFile = map(F, Spec),
+ Hosts =
+ case lists:keysearch(hosts, 1, Vars) of
+ false ->
+ [];
+ {value, {hosts, HostList}} ->
+ io_lib:format("{hosts,~p}.~n",[HostList])
+ end,
+ DiskLess =
+ case lists:keysearch(diskless, 1, Vars) of
+ false ->
+ [];
+ {value, {diskless, How}} ->
+ io_lib:format("{diskless, ~p}.~n",[How])
+ end,
+ Conf = consult_config(),
+ MoreConfig = io_lib:format("~p.\n", [{config,Conf}]),
+ file:write_file("current.spec", [DiskLess,Hosts,MoreConfig,SpecFile]).
+
+consult_config() ->
+ {ok,Conf} = file:consult("ts.config"),
+ case os:type() of
+ {unix,_} -> consult_config("ts.unix.config", Conf);
+ {win32,_} -> consult_config("ts.win32.config", Conf);
+ vxworks -> consult_config("ts.vxworks.config", Conf);
+ _ -> Conf
+ end.
+
+consult_config(File, Conf0) ->
+ case file:consult(File) of
+ {ok,Conf} -> Conf++Conf0;
+ {error,enoent} -> Conf0
+ end.
+
+%% Makes the command to start up the Erlang node to run the tests.
+
+backslashify([$\\, $" | T]) ->
+ [$\\, $" | backslashify(T)];
+backslashify([$" | T]) ->
+ [$\\, $" | backslashify(T)];
+backslashify([H | T]) ->
+ [H | backslashify(T)];
+backslashify([]) ->
+ [].
+
+make_command(Vars, Spec, State) ->
+ TestDir = State#state.test_dir,
+ TestPath = filename:nativename(TestDir),
+ Erl = case os:getenv("TS_RUN_VALGRIND") of
+ false ->
+ atom_to_list(lib:progname());
+ _ ->
+ case State#state.file of
+ Dir when is_list(Dir) ->
+ os:putenv("VALGRIND_LOGFILE_PREFIX", Dir++"-");
+ _ ->
+ ok
+ end,
+ "cerl -valgrind" ++
+ case erlang:system_info(smp_support) of
+ true -> " -smp";
+ false -> ""
+ end
+ end,
+ Naming =
+ case ts_lib:var(longnames, Vars) of
+ true ->
+ " -name ";
+ false ->
+ " -sname "
+ end,
+ ExtraArgs =
+ case lists:keysearch(erl_start_args,1,Vars) of
+ {value,{erl_start_args,Args}} -> Args;
+ false -> ""
+ end,
+ CrashFile = State#state.file ++ "_erl_crash.dump",
+ case filelib:is_file(CrashFile) of
+ true ->
+ io:format("ts_run: Deleting dump: ~s\n",[CrashFile]),
+ file:delete(CrashFile);
+ false ->
+ ok
+ end,
+ Cmd = [Erl, Naming, "test_server -pa ", $", TestPath, $",
+ " -rsh ", ts_lib:var(rsh_name, Vars),
+ " -env PATH \"",
+ backslashify(lists:flatten([TestPath, path_separator(),
+ remove_path_spaces()])),
+ "\"",
+ " -env ERL_CRASH_DUMP ", CrashFile,
+ %% uncomment the line below to disable exception formatting
+ %% " -test_server_format_exception false",
+ " -boot start_sasl -sasl errlog_type error",
+ " -s test_server_ctrl run_test ", State#state.test_server_args,
+ " ",
+ ExtraArgs],
+ {ok, Vars, Spec, State#state{command=lists:flatten(Cmd)}}.
+
+run_batch(Vars, _Spec, State) ->
+ process_flag(trap_exit, true),
+ Command = State#state.command ++ " -noinput -s erlang halt",
+ ts_lib:progress(Vars, 1, "Command: ~s~n", [Command]),
+ Port = open_port({spawn, Command}, [stream, in, eof]),
+ tricky_print_data(Port).
+
+tricky_print_data(Port) ->
+ receive
+ {Port, {data, Bytes}} ->
+ io:put_chars(Bytes),
+ tricky_print_data(Port);
+ {Port, eof} ->
+ Port ! {self(), close},
+ receive
+ {Port, closed} ->
+ true
+ end,
+ receive
+ {'EXIT', Port, _} ->
+ ok
+ after 1 -> % force context switch
+ ok
+ end
+ after 30000 ->
+ case erl_epmd:names() of
+ {ok,Names} ->
+ case is_testnode_dead(Names) of
+ true ->
+ io:put_chars("WARNING: No EOF, but "
+ "test_server node is down!\n");
+ false ->
+ tricky_print_data(Port)
+ end;
+ _ ->
+ tricky_print_data(Port)
+ end
+ end.
+
+is_testnode_dead([]) -> true;
+is_testnode_dead([{"test_server",_}|_]) -> false;
+is_testnode_dead([_|T]) -> is_testnode_dead(T).
+
+run_interactive(Vars, _Spec, State) ->
+ Command = State#state.command ++ " -s ts_reports make_index",
+ ts_lib:progress(Vars, 1, "Command: ~s~n", [Command]),
+ case ts_lib:var(os, Vars) of
+ "Windows 95" ->
+ %% Windows 95 strikes again! We must redirect standard
+ %% input and output for the `start' command, to force
+ %% standard input and output to the Erlang shell to be
+ %% connected to the newly started console.
+ %% Without these redirections, the Erlang shell would be
+ %% connected to the pipes provided by the port program
+ %% and there would be an inactive console window.
+ os:cmd("start < nul > nul w" ++ Command),
+ ok;
+ "Windows 98" ->
+ os:cmd("start < nul > nul w" ++ Command),
+ ok;
+ "Windows"++_ ->
+ os:cmd("start w" ++ Command),
+ ok;
+ _Other ->
+ %% Assuming ts and controller always run on solaris
+ start_xterm(Command)
+ end.
+
+start_xterm(Command) ->
+ case os:find_executable("xterm") of
+ false ->
+ io:format("The `xterm' program was not found.\n"),
+ {error, no_xterm};
+ _Xterm ->
+ case os:getenv("DISPLAY") of
+ false ->
+ io:format("DISPLAY is not set.\n"),
+ {error, display_not_set};
+ Display ->
+ io:format("Starting xterm (DISPLAY=~s)...\n",
+ [Display]),
+ os:cmd("xterm -sl 10000 -e " ++ Command ++ "&"),
+ ok
+ end
+ end.
+
+path_separator() ->
+ case os:type() of
+ {win32, _} -> ";";
+ {unix, _} -> ":";
+ vxworks -> ":"
+ end.
+
+
+make_test_server_args(Args0,Options,Vars) ->
+ Parameters =
+ case ts_lib:var(os, Vars) of
+ "VxWorks" ->
+ F = write_parameterfile(vxworks,Vars),
+ " PARAMETERS " ++ F;
+ "OSE" ->
+ F = write_parameterfile(ose,Vars),
+ " PARAMETERS " ++ F;
+ _ ->
+ ""
+ end,
+ Trace =
+ case lists:keysearch(trace,1,Options) of
+ {value,{trace,TI}} when is_tuple(TI); is_tuple(hd(TI)) ->
+ ok = file:write_file(?tracefile,io_lib:format("~p.~n",[TI])),
+ " TRACE " ++ ?tracefile;
+ {value,{trace,TIFile}} when is_atom(TIFile) ->
+ " TRACE " ++ atom_to_list(TIFile);
+ {value,{trace,TIFile}} ->
+ " TRACE " ++ TIFile;
+ false ->
+ ""
+ end,
+ Cover =
+ case lists:keysearch(cover,1,Options) of
+ {value,{cover,App,File,Analyse}} ->
+ " COVER " ++ to_list(App) ++ " " ++ to_list(File) ++ " " ++
+ to_list(Analyse);
+ false ->
+ ""
+ end,
+ TCCallback =
+ case ts_lib:var(ts_testcase_callback, Vars) of
+ "" ->
+ "";
+ {Mod,Func} ->
+ io:format("Function ~w:~w/4 will be called before and "
+ "after each test case.\n", [Mod,Func]),
+ " TESTCASE_CALLBACK " ++ to_list(Mod) ++ " " ++ to_list(Func);
+ ModFunc when is_list(ModFunc) ->
+ [Mod,Func]=string:tokens(ModFunc," "),
+ io:format("Function ~s:~s/4 will be called before and "
+ "after each test case.\n", [Mod,Func]),
+ " TESTCASE_CALLBACK " ++ ModFunc;
+ _ ->
+ ""
+ end,
+ Args0 ++ Parameters ++ Trace ++ Cover ++ TCCallback.
+
+to_list(X) when is_atom(X) ->
+ atom_to_list(X);
+to_list(X) when is_list(X) ->
+ X.
+
+write_parameterfile(Type,Vars) ->
+ Cross_host = ts_lib:var(target_host, Vars),
+ SlaveTargets = case lists:keysearch(slavetargets,1,Vars) of
+ {value, ST} ->
+ [ST];
+ _ ->
+ []
+ end,
+ Master = case lists:keysearch(master,1,Vars) of
+ {value,M} -> [M];
+ false -> []
+ end,
+ ToWrite = [{type,Type},
+ {target, list_to_atom(Cross_host)}] ++ SlaveTargets ++ Master,
+
+ Crossfile = atom_to_list(Type) ++ "parameters" ++ os:getpid(),
+ ok = file:write_file(Crossfile,io_lib:format("~p.~n", [ToWrite])),
+ Crossfile.
+
+%%
+%% Paths and spaces handling for w2k and XP
+%%
+remove_path_spaces() ->
+ Path = os:getenv("PATH"),
+ case os:type() of
+ {win32,nt} ->
+ remove_path_spaces(Path);
+ _ ->
+ Path
+ end.
+
+remove_path_spaces(Path) ->
+ SPath = split_path(Path),
+ [NSHead|NSTail] = lists:map(fun(X) -> filename:nativename(
+ filename:join(
+ translate_path(split_one(X))))
+ end,
+ SPath),
+ NSHead ++ lists:flatten([[$;|X] || X <- NSTail]).
+
+translate_path(PList) ->
+ %io:format("translate_path([~p|~p]~n",[Base,PList]),
+ translate_path(PList,[]).
+
+
+translate_path([],_) ->
+ [];
+translate_path([PC | T],BaseList) ->
+ FullPath = filename:nativename(filename:join(BaseList ++ [PC])),
+ NewPC = case catch file:altname(FullPath) of
+ {ok,X} ->
+ X;
+ _ ->
+ PC
+ end,
+ %io:format("NewPC:~s, DirList:~p~n",[NewPC,DirList]),
+ NewBase = BaseList ++ [NewPC],
+ [NewPC | translate_path(T,NewBase)].
+
+split_one(Path) ->
+ filename:split(Path).
+
+split_path(Path) ->
+ string:tokens(Path,";").
+
+
diff --git a/lib/test_server/src/ts_selftest.erl b/lib/test_server/src/ts_selftest.erl
new file mode 100644
index 0000000000..655aa4bab3
--- /dev/null
+++ b/lib/test_server/src/ts_selftest.erl
@@ -0,0 +1,120 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(ts_selftest).
+-export([selftest/0]).
+
+selftest() ->
+ case node() of
+ nonode@nohost ->
+ io:format("Sorry, you have to start this node distributed.~n"),
+ exit({error, node_not_distributed});
+ _ ->
+ ok
+ end,
+ case catch ts:tests(test_server) of
+ {'EXIT', _} ->
+ io:format("Test Server self test not availiable.");
+ Other ->
+ selftest1()
+ end.
+
+selftest1() ->
+ % Batch starts
+ io:format("Selftest #1: Whole spec, batch mode:~n"),
+ io:format("------------------------------------~n"),
+ ts:run(test_server, [batch]),
+ ok=check_result(1, "test_server.logs", 2),
+
+ io:format("Selftest #2: One module, batch mode:~n"),
+ io:format("------------------------------------~n"),
+ ts:run(test_server, test_server_SUITE, [batch]),
+ ok=check_result(2, "test_server_SUITE.logs", 2),
+
+ io:format("Selftest #3: One testcase, batch mode:~n"),
+ io:format("--------------------------------------~n"),
+ ts:run(test_server, test_server_SUITE, msgs, [batch]),
+ ok=check_result(3, "test_server_SUITE.logs", 0),
+
+ % Interactive starts
+ io:format("Selftest #4: Whole spec, interactive mode:~n"),
+ io:format("------------------------------------------~n"),
+ ts:run(test_server),
+ kill_test_server(),
+ ok=check_result(4, "test_server.logs", 2),
+
+ io:format("Selftest #5: One module, interactive mode:~n"),
+ io:format("------------------------------------------~n"),
+ ts:run(test_server, test_server_SUITE),
+ kill_test_server(),
+ ok=check_result(5, "test_server_SUITE.logs", 2),
+
+ io:format("Selftest #6: One testcase, interactive mode:~n"),
+ io:format("--------------------------------------------~n"),
+ ts:run(test_server, test_server_SUITE, msgs),
+ kill_test_server(),
+ ok=check_result(6, "test_server_SUITE.logs", 0),
+
+ ok.
+
+check_result(Test, TDir, ExpSkip) ->
+ Dir=ts_lib:last_test(TDir),
+ {Total, Failed, Skipped}=ts_reports:count_cases(Dir),
+ io:format("Selftest #~p:",[Test]),
+ case {Total, Failed, Skipped} of
+ {_, 0, ExpSkip} -> % 2 test cases should be skipped.
+ io:format("All ok.~n~n"),
+ ok;
+ {_, _, _} ->
+ io:format("Not completely successful.~n~n"),
+ error
+ end.
+
+
+%% Wait for test server to get started.
+kill_test_server() ->
+ Node=list_to_atom("test_server@"++atom_to_list(hostname())),
+ net_adm:ping(Node),
+ case whereis(test_server_ctrl) of
+ undefined ->
+ kill_test_server();
+ Pid ->
+ kill_test_server(0, Pid)
+ end.
+
+%% Wait for test server to finish.
+kill_test_server(30, Pid) ->
+ exit(self(), test_server_is_dead);
+kill_test_server(Num, Pid) ->
+ case whereis(test_server_ctrl) of
+ undefined ->
+ slave:stop(node(Pid));
+ Pid ->
+ receive
+ after
+ 1000 ->
+ kill_test_server(Num+1, Pid)
+ end
+ end.
+
+
+hostname() ->
+ list_to_atom(from($@, atom_to_list(node()))).
+from(H, [H | T]) -> T;
+from(H, [_ | T]) -> from(H, T);
+from(H, []) -> [].
diff --git a/lib/test_server/src/vxworks_client.erl b/lib/test_server/src/vxworks_client.erl
new file mode 100644
index 0000000000..ca65eca02a
--- /dev/null
+++ b/lib/test_server/src/vxworks_client.erl
@@ -0,0 +1,243 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2002-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(vxworks_client).
+
+-export([open/1, close/1, send_data/2, send_data/3, send_data_wait_for_close/2, reboot/1]).
+-export([init/2]).
+
+-include("ts.hrl").
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% This is a client talking to a test server daemon on a VxWorks card.
+%%%
+%%% User interface:
+%%%
+%%% open/1
+%%% Start a client and establish the connection with the test server daemon
+%%%
+%%% send_data/2
+%%% Send data/command to the test server daemon, don't wait for any return
+%%%
+%%% send_data/3
+%%% Send data/command to the test server daemon and wait for the given
+%%% return value.
+%%%
+%%% send_data_wait_for_close/2
+%%% Send data/command to the test server daemon and wait for the daemon to
+%%% close the connection.
+%%%
+%%% close/1
+%%% Close the client.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%%
+%% User interface
+%%
+
+reboot(Target) ->
+ {ok, {_,_,_,_,_,[Addr|_]}} = inet:gethostbyname(Target),
+ Fun = fun({ok, Socket}) ->
+ gen_tcp:send(Socket, "q\n"),
+ receive
+ {tcp_closed, Socket} ->
+ gen_tcp:close(Socket),
+ {ok, socket_closed}
+ after 5000 ->
+ exit({timeout, tryagain})
+ end
+ end,
+ io:format("Stopping (rebooting) ~p ",[Target]),
+ case fun_target(Addr, Fun) of
+ {ok, socket_closed} ->
+ ok;
+ _Else ->
+ io:format("No contact with ts daemon - exiting ...~n"),
+ exit({stop, no_ts_daemon_contact})
+ end.
+
+
+%% open(Target) -> {ok,Client} | {error, Reason}
+open(Target) ->
+ {ok, {_,_,_,_,_,[Addr|_]}} = inet:gethostbyname(Target),
+ Fun = fun({ok, Socket}) ->
+ P = spawn(?MODULE,init,[Target,Socket]),
+ inet_tcp:controlling_process(Socket,P),
+ {ok,P}
+ end,
+ case fun_target(Addr,Fun) of
+ {ok, Pid} ->
+ {ok, Pid};
+ {error,Reason} ->
+ {error, Reason}
+ end.
+
+%% send_data(Client,Data) -> ok
+send_data(Pid,Data) ->
+ Pid ! {send_data,Data++"\n"},
+ ok.
+
+%% send_data(Client,Data,ExpectedReturn) -> {ok,ExpectedReturn} | {error,Reason}
+send_data(Pid,Data,Return) ->
+ Pid ! {send_data,Data++"\n",Return,self()},
+ receive {Pid,Result} -> Result end.
+
+%% send_data_wait_for_close(Client,Data) -> ok | {error,Reason}
+send_data_wait_for_close(Pid,Data) ->
+ send_data(Pid,Data,tcp_closed).
+
+%% close(Client) -> ok
+close(Pid) ->
+ Pid ! close,
+ ok.
+
+
+%%
+%% Internal
+%%
+
+init(Target,Socket) ->
+ process_flag(trap_exit,true),
+ loop(Target,Socket).
+
+loop(Target,Socket) ->
+ receive
+ {send_data,Data} ->
+ %% io:format("vx client sending: ~p~n", [Data]),
+ gen_tcp:send(Socket, Data),
+ loop(Socket,Target);
+ {send_data,Data,tcp_closed,From} ->
+ %% io:format("vx client sending: ~p~n", [Data]),
+ gen_tcp:send(Socket, Data),
+ receive
+ {tcp_closed, Socket} ->
+ From ! {self(),ok}
+ after 5000 ->
+ From ! {self(),{error,timeout}}
+ end,
+ closed(Socket,normal);
+ {send_data,Data,Return,From} ->
+ %% io:format("vx client sending: ~p~n", [Data]),
+ gen_tcp:send(Socket, Data),
+ case receive_line(Socket,[],Return,200) of
+ {tcp_closed, Socket} ->
+ From ! {self(),{error,{socket_closed,Target}}},
+ closed(Socket,{socket_closed,Target});
+ {tcp,Socket,_Rest} ->
+ From ! {self(),{ok,Data}},
+ got_data(Target,Socket,Data);
+ error ->
+ From ! {self(),{error,{catatonic,Target}}}
+ end;
+ close ->
+ closed(Socket,normal);
+ {tcp_closed, Socket} ->
+ closed(Socket,{socket_closed,Target});
+ {tcp,Socket,Data} ->
+ got_data(Target,Socket,Data)
+ end.
+
+
+
+closed(Socket,Reason) ->
+ gen_tcp:close(Socket),
+ exit(Reason).
+
+got_data(Target,Socket,Data) ->
+ if is_atom(Target) ->
+ io:format("~w: ~s",[Target,uncr(Data)]);
+ true ->
+ io:format("~s: ~s",[Target,uncr(Data)])
+ end,
+ loop(Target,Socket).
+
+uncr([]) ->
+ [];
+uncr([$\r | T]) ->
+ uncr(T);
+uncr([H | T]) ->
+ [H | uncr(T)].
+
+strip_line(Line) ->
+ RPos = string:rchr(Line, $\n),
+ string:substr(Line,RPos+1).
+
+maybe_done_receive(Socket,Ack,Match,C) ->
+ case string:str(Ack,Match) of
+ 0 ->
+ receive_line(Socket,strip_line(Ack),Match,C);
+ _ ->
+ {tcp,Socket,strip_line(Ack)}
+ end.
+
+
+receive_line(_Socket,_Ack,_Match,0) ->
+ error;
+receive_line(Socket,Ack,Match,Counter) ->
+ receive
+ {tcp_closed, Socket} ->
+ {tcp_closed, Socket};
+ {tcp,Socket,Data} ->
+ NewAck = Ack ++ Data,
+ case {string:str(NewAck,"\r") > 0,
+ string:str(NewAck,"\n") > 0} of
+ {true,_} ->
+ maybe_done_receive(Socket,NewAck,Match,Counter-1);
+ {_,true} ->
+ maybe_done_receive(Socket,NewAck,Match,Counter-1);
+ _ ->
+ receive_line(Socket,NewAck,Match,Counter)
+ end
+ after 20000 ->
+ error
+ end.
+
+
+%% Misc functions
+fun_target(Addr, Fun) ->
+ io:format("["),
+ fun_target(Addr, Fun, 60). %Vx-cards need plenty of time.
+
+fun_target(_Addr, _Fun, 0) ->
+ io:format(" no contact with ts daemon]~n"),
+ {error,failed_to_connect};
+fun_target(Addr, Fun, Tries_left) ->
+ receive after 1 -> ok end,
+ case do_connect(Addr, Fun) of
+ {ok, Value} ->
+ io:format(" ok]~n"),
+ {ok, Value};
+ _Error -> % typical {error, econnrefused}
+ io:format("."),
+ receive after 10000 -> ok end,
+ fun_target(Addr, Fun, Tries_left-1)
+ end.
+
+do_connect(Addr, Fun) ->
+ case gen_tcp:connect(Addr, ?TS_PORT, [{reuseaddr, true}], 60000) of
+ {ok, Socket} ->
+ Fun({ok, Socket});
+ Error ->
+ Error
+ end.
+
+
+