From 2616528b847ab64dac20241092243f10e482cb14 Mon Sep 17 00:00:00 2001 From: Dalibor Pospisil Date: Wed, 13 Dec 2017 19:20:50 +0100 Subject: [PATCH] release 1.17-5 --- beakerlib.spec | 26 +++++- enable-nested-phases.patch | 35 +++++++ get-text-journal-size.patch | 21 +++++ ifs-issue.patch | 128 ++++++++++++++++++++++++++ journaling-fixes.patch | 64 +++++++++++++ reduce-meta.patch | 25 +++++ result-file.patch | 177 ++++++++++++++++++++++++++++++++++++ var-TEST.patch | 41 +++++++++ 8 files changed, 516 insertions(+), 1 deletion(-) create mode 100644 enable-nested-phases.patch create mode 100644 get-text-journal-size.patch create mode 100644 ifs-issue.patch create mode 100644 journaling-fixes.patch create mode 100644 reduce-meta.patch create mode 100644 result-file.patch create mode 100644 var-TEST.patch diff --git a/beakerlib.spec b/beakerlib.spec index 44d72b7..8b8922d 100644 --- a/beakerlib.spec +++ b/beakerlib.spec @@ -1,7 +1,7 @@ Name: beakerlib Summary: A shell-level integration testing library Version: 1.17 -Release: 4%{?dist} +Release: 5%{?dist} License: GPLv2 Group: Development/Libraries BuildRoot: %{_tmppath}/%{name}-%{version}-root @@ -37,6 +37,13 @@ Requires: vim-common BuildRequires: vim-common Patch0: test-built-time.patch +Patch1: result-file.patch +Patch2: ifs-issue.patch +Patch3: journaling-fixes.patch +Patch4: get-text-journal-size.patch +Patch5: var-TEST.patch +Patch6: reduce-meta.patch +Patch7: enable-nested-phases.patch %description vim-syntax Files for syntax highlighting BeakerLib tests in VIM editor @@ -44,6 +51,13 @@ Files for syntax highlighting BeakerLib tests in VIM editor %prep %setup -q %patch0 -p1 -b .test-built-time +%patch1 -p1 -b .result-file +%patch2 -p1 -b .ifs-issue +%patch3 -p1 -b .journaling-fixes +%patch4 -p1 -b .get-text-journal-size +%patch5 -p1 -b .var-TEST +%patch6 -p1 -b .reduce-meta +%patch7 -p1 -b .enable-nested-phases %build make build @@ -81,6 +95,16 @@ rm -rf $RPM_BUILD_ROOT %{_datadir}/vim/vimfiles/after/syntax/beakerlib.vim %changelog +* Wed Dec 13 2017 Dalibor Pospisil - 1.17-5 +- result file tweaks +- fixed ifs issue +- improved performance of journaling.py +- fixed computing the length of text text journal per phase +- use internal test name and do not touch TEST variable if empty +- omit human readable meta file comments in non-debug mode +- enable nested phases by default + + * Fri Oct 20 2017 Dalibor Pospisil - 1.17-4 - updated dependecies set diff --git a/enable-nested-phases.patch b/enable-nested-phases.patch new file mode 100644 index 0000000..1e6ef9c --- /dev/null +++ b/enable-nested-phases.patch @@ -0,0 +1,35 @@ +From 7381fd558e64559029980def31faf6661909eeb8 Mon Sep 17 00:00:00 2001 +From: Dalibor Pospisil +Date: Tue, 12 Dec 2017 16:04:01 +0100 +Subject: [PATCH 16/18] nested phases enabled by default + +this prevents some yet undocumented and officily unsupported behavoiur regression +--- + src/journal.sh | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/journal.sh b/src/journal.sh +index 374ddfc..516f292 100644 +--- a/src/journal.sh ++++ b/src/journal.sh +@@ -539,7 +539,7 @@ rljAddPhase(){ + # Printing + __INTERNAL_PrintHeadLog "$MSG" + +- if [[ -z "$BEAKERLIB_NESTED_PHASES" ]]; then ++ if [[ "$BEAKERLIB_NESTED_PHASES" == "0" ]]; then + __INTERNAL_METAFILE_INDENT_LEVEL=2 + __INTERNAL_PHASE_TYPE=( "$1" ) + __INTERNAL_PHASE_NAME=( "$MSG" ) +@@ -612,7 +612,7 @@ rljClosePhase(){ + rm -f $logfile + + # Reset of state variables +- if [[ -z "$BEAKERLIB_NESTED_PHASES" ]]; then ++ if [[ "$BEAKERLIB_NESTED_PHASES" == "0" ]]; then + __INTERNAL_METAFILE_INDENT_LEVEL=1 + __INTERNAL_PHASE_TYPE=() + __INTERNAL_PHASE_NAME=() +-- +2.14.3 + diff --git a/get-text-journal-size.patch b/get-text-journal-size.patch new file mode 100644 index 0000000..0d2ac4f --- /dev/null +++ b/get-text-journal-size.patch @@ -0,0 +1,21 @@ +diff -u b/src/journal.sh b/src/journal.sh +--- b/src/journal.sh ++++ b/src/journal.sh +@@ -531,7 +531,7 @@ + rljAddPhase(){ + __INTERNAL_PersistentDataLoad + local MSG=${2:-"Phase of $1 type"} +- local TXTLOG_START=$(wc -l $__INTERNAL_BEAKERLIB_JOURNAL_TXT) ++ local TXTLOG_START=$(cat $__INTERNAL_BEAKERLIB_JOURNAL_TXT | wc -l) + rlLogDebug "rljAddPhase: Phase $MSG started" + __INTERNAL_WriteToMetafile phase --name "$MSG" --type "$1" >&2 + # Printing +@@ -546,7 +546,7 @@ + __INTERNAL_PHASE_FAILED=( 0 ) + __INTERNAL_PHASE_PASSED=( 0 ) + __INTERNAL_PHASE_STARTTIME=( $__INTERNAL_TIMESTAMP ) +- __INTERNAL_PHASE_TXTLOG_START=( $(wc -l $__INTERNAL_BEAKERLIB_JOURNAL_TXT) ) ++ __INTERNAL_PHASE_TXTLOG_START=( $TXTLOG_START ) + __INTERNAL_PHASE_OPEN=${#__INTERNAL_PHASE_NAME[@]} + __INTERNAL_PHASE_METRICS=( "" ) + else diff --git a/ifs-issue.patch b/ifs-issue.patch new file mode 100644 index 0000000..0d483f5 --- /dev/null +++ b/ifs-issue.patch @@ -0,0 +1,128 @@ +diff -u b/src/journal.sh b/src/journal.sh +--- b/src/journal.sh ++++ b/src/journal.sh +@@ -431,12 +431,10 @@ + [[ -t 1 ]] && textfile="$__INTERNAL_BEAKERLIB_JOURNAL_COLORED" || textfile="$__INTERNAL_BEAKERLIB_JOURNAL_TXT" + cat "$textfile" + +- local tmp="$__INTERNAL_LogText_no_file" +- __INTERNAL_LogText_no_file=1 ++ local __INTERNAL_LogText_no_file=1 + __INTERNAL_PrintHeadLog "${TEST}" 2>&1 + __INTERNAL_LogText "Phases: $__INTERNAL_PHASES_PASSED good, $__INTERNAL_PHASES_FAILED bad" LOG 2>&1 + __INTERNAL_LogText "RESULT: $TEST" $__INTERNAL_PHASES_WORST_RESULT 2>&1 +- __INTERNAL_LogText_no_file=$tmp + + return 0 + } +@@ -645,6 +643,7 @@ + # $2 result + # $3 command + rljAddTest(){ ++ local IFS + __INTERNAL_PersistentDataLoad + if [ $__INTERNAL_PHASE_OPEN -eq 0 ]; then + rlPhaseStart "FAIL" "Asserts collected outside of a phase" +@@ -723,6 +722,7 @@ + + # Creates header + __INTERNAL_CreateHeader(){ ++ local IFS + + __INTERNAL_PrintHeadLog "TEST PROTOCOL" 2> /dev/null + +@@ -816,7 +816,7 @@ + local count=0 + local type="unknown" + local cpu_regex="^model\sname.*: (.*)$" +- while read line; do ++ while read -r line; do + if [[ "$line" =~ $cpu_regex ]]; then + type="${BASH_REMATCH[1]}" + let count++ +@@ -830,7 +830,7 @@ + if [[ -f "/proc/meminfo" ]]; then + size=0 + local ram_regex="^MemTotal: *(.*) kB$" +- while read line; do ++ while read -r line; do + if [[ "$line" =~ $ram_regex ]]; then + size=`expr ${BASH_REMATCH[1]} / 1024` + break +diff -u b/src/logging.sh b/src/logging.sh +--- b/src/logging.sh ++++ b/src/logging.sh +@@ -53,10 +53,8 @@ + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + __INTERNAL_PrintText() { +- local tmp="$__INTERNAL_LogText_no_file" +- __INTERNAL_LogText_no_file=1 ++ local __INTERNAL_LogText_no_file=1 + __INTERNAL_LogText "$@" +- __INTERNAL_LogText_no_file=$tmp + } + + __INTERNAL_LogText() { +@@ -531,6 +529,7 @@ + rlShowPackageVersion() + { + local score=0 ++ local IFS + if [ $# -eq 0 ]; then + rlLogWarning "rlShowPackageVersion: Too few options" + return 1 +only in patch2: +unchanged: +--- a/src/analyze.sh ++++ b/src/analyze.sh +@@ -76,6 +76,7 @@ Return 0 if... TODO + =cut + + rlDejaSum(){ ++ local IFS + rlLog "Summarizing files: $1 $2" + rlLogDebug "Calling beakerlib-deja-summarize routine" + beakerlib-deja-summarize $1 $2 | while read line +only in patch2: +unchanged: +--- a/src/libraries.sh ++++ b/src/libraries.sh +@@ -268,9 +268,10 @@ __INTERNAL_envdebugget() { + __INTERNAL_envdebugdiff() { + rlLogDebug "rlImport: library $1 changes following environment; changed functions are marked with asterisk (*)" + diff -U0 <(echo "$__INTERNAL_envdebugvariables") <(__INTERNAL_envdebugget 1) | tail -n +3 | grep -E -v '^@@' +- local line fn print='' print2 LF=" +-" +- while IFS= read line; do ++ local line fn print='' print2 LF=$'\n' ++ local IFS ++ ++ while read -r line; do + [[ "$line" =~ ^(.)([^[:space:]]+)[[:space:]]\(\) ]] && { + [[ -n "$print" ]] && { + echo "$fn" +only in patch2: +unchanged: +--- a/src/rpms.sh ++++ b/src/rpms.sh +@@ -56,6 +56,7 @@ __INTERNAL_RpmPresent() { + local version=$3 + local release=$4 + local arch=$5 ++ local IFS + + local package=$name-$version-$release.$arch + [ "$arch" == "" ] && package=$name-$version-$release +only in patch2: +unchanged: +--- a/src/testing.sh ++++ b/src/testing.sh +@@ -749,6 +749,7 @@ rlRun() { + local __INTERNAL_rlRun_TAG_OUT='' + local __INTERNAL_rlRun_TAG_ERR='' + local __INTERNAL_rlRun_LOG_FILE='' ++ local IFS + + while true ; do + case "$1" in diff --git a/journaling-fixes.patch b/journaling-fixes.patch new file mode 100644 index 0000000..fb38309 --- /dev/null +++ b/journaling-fixes.patch @@ -0,0 +1,64 @@ +diff -u b/src/python/journalling.py b/src/python/journalling.py +--- b/src/python/journalling.py ++++ b/src/python/journalling.py +@@ -27,7 +27,6 @@ + import re + from optparse import OptionParser + from lxml import etree +-import shlex + import base64 + + # TODO fix xml pretty print +@@ -100,8 +99,8 @@ + # Count number of leading spaces + indent = len(line) - len(line.lstrip()) + +- # using shlex to get rid of the quotes +- splitted = shlex.split(line) ++ # splitting the line into list ++ splitted = line.split() + + # if the line is not empty + if splitted: +@@ -118,7 +117,9 @@ + for part in splitted: + # if flag is set, string is an elements content + if CONTENT_FLAG == 1: +- content = base64.b64decode(part) ++ # First and last characters(quotes) stripped and ++ # string is decoded from base64 ++ content = base64.b64decode(part[1:-1]) + # end parsing after content is stored + break + # test if string is an elements content indicator +@@ -128,13 +129,15 @@ + # test if string is an elements time attribute + if re.match(r'^--timestamp=', part): + attribute_name = "timestamp" +- attribute_value = part.split('=', 1)[1] ++ # Value is string after '=' sign and without first abd last char(quotes) ++ attribute_value = part.split('=', 1)[1][1:-1] + attributes[attribute_name] = time.strftime(TIME_FORMAT, time.localtime(int(attribute_value))) + continue + # test if string is an elements regular attribute + if re.match(r'^--[a-zA-Z0-9]+=', part): + attribute_name = part.split('=', 1)[0][2:] +- attribute_value = part.split('=', 1)[1] ++ # Value is string after '=' sign and without first abd last char(quotes) ++ attribute_value = part.split('=', 1)[1][1:-1] + attributes[attribute_name] = base64.b64decode(attribute_value) + continue + +@@ -145,7 +148,11 @@ + # information given as parameters + def createElement(element, attributes, content): + element = unicode(element, 'utf-8', errors='replace').translate(xmlTrans) +- new_el = etree.Element(element) ++ try: ++ new_el = etree.Element(element) ++ except ValueError, e: ++ sys.stderr.write('Failed to create element with name %s\nError: %s\nExiting unsuccessfully.\n' % (element, e)) ++ exit(1) + + content = unicode(content, 'utf-8', errors='replace').translate(xmlTrans) + new_el.text = content diff --git a/reduce-meta.patch b/reduce-meta.patch new file mode 100644 index 0000000..b7ecbbf --- /dev/null +++ b/reduce-meta.patch @@ -0,0 +1,25 @@ +unchanged: +--- a/src/journal.sh ++++ b/src/journal.sh +@@ -922,7 +922,7 @@ __INTERNAL_WriteToMetafile(){ + + line="$indent${element:+$element }--timestamp=\"${__INTERNAL_TIMESTAMP}\"$line" + lineraw="$indent${element:+$element }--timestamp=\"${__INTERNAL_TIMESTAMP}\"$lineraw" +- echo "#${lineraw:1}" >> $__INTERNAL_BEAKERLIB_METAFILE ++ [[ -n "$DEBUG" ]] && echo "#${lineraw:1}" >> $__INTERNAL_BEAKERLIB_METAFILE + echo "$line" >> $__INTERNAL_BEAKERLIB_METAFILE + } + +only in patch2: +unchanged: +--- a/src/test/journalTest.sh ++++ b/src/test/journalTest.sh +@@ -26,7 +26,7 @@ test_rlJournalStart(){ + assertTrue "journal is well-formed XML" "xmllint $__INTERNAL_BEAKERLIB_JOURNAL >/dev/null" + + # existing journal is not overwritten +- silentIfNotDebug 'rlLog "I am"' ++ silentIfNotDebug 'DEBUG=1 rlLog "I am"' + rlJournalStart + assertTrue "existing meta not overwritten" \ + "grep 'I\\\ am' $__INTERNAL_BEAKERLIB_METAFILE" diff --git a/result-file.patch b/result-file.patch new file mode 100644 index 0000000..76267a0 --- /dev/null +++ b/result-file.patch @@ -0,0 +1,177 @@ +diff -u b/src/journal.sh b/src/journal.sh +--- b/src/journal.sh ++++ b/src/journal.sh +@@ -115,12 +115,13 @@ + export __INTERNAL_METAFILE_INDENT_LEVEL=0 + __INTERNAL_PHASE_TYPE=() + __INTERNAL_PHASE_NAME=() +- export __INTERNAL_PRESISTENT_DATA="$BEAKERLIB_DIR/PersistentData" ++ export __INTERNAL_PERSISTENT_DATA="$BEAKERLIB_DIR/PersistentData" ++ export __INTERNAL_TEST_RESULTS="$BEAKERLIB_DIR/TestResults" + export __INTERNAL_JOURNAL_OPEN='' + __INTERNAL_PersistentDataLoad + export __INTERNAL_PHASES_FAILED=0 + export __INTERNAL_PHASES_PASSED=0 +- export __INTERNAL_PHASES_SKIPED=0 ++ export __INTERNAL_PHASES_SKIPPED=0 + export __INTERNAL_PHASES_WORST_RESULT='PASS' + export __INTERNAL_TEST_STATE=0 + __INTERNAL_PHASE_TXTLOG_START=() +@@ -249,6 +250,7 @@ + + echo "#End of metafile" >> $__INTERNAL_BEAKERLIB_METAFILE + __INTERNAL_JournalXMLCreate ++ __INTERNAL_TestResultsSave + } + + +@@ -346,11 +348,11 @@ + + __INTERNAL_update_journal_txt() { + local textfile +- local duration=$(($__INTERNAL_TIMESTAMP - $__INTERNAL_STARTTIME)) + local endtime ++ __INTERNAL_DURATION=$(($__INTERNAL_TIMESTAMP - $__INTERNAL_STARTTIME)) + printf -v endtime "%($__INTERNAL_TIMEFORMAT_LONG)T %s" $__INTERNAL_TIMESTAMP "(still running)" + [[ -n "$__INTERNAL_ENDTIME" ]] && printf -v endtime "%($__INTERNAL_TIMEFORMAT_LONG)T" $__INTERNAL_ENDTIME +- local sed_patterns="0,/ Test finished : /s/^( Test finished : ).*\$/\1$endtime/;0,/ Test duration : /s/^( Test duration : ).*\$/\1$duration seconds/" ++ local sed_patterns="0,/ Test finished : /s/^( Test finished : ).*\$/\1$endtime/;0,/ Test duration : /s/^( Test duration : ).*\$/\1$__INTERNAL_DURATION seconds/" + for textfile in "$__INTERNAL_BEAKERLIB_JOURNAL_COLORED" "$__INTERNAL_BEAKERLIB_JOURNAL_TXT"; do + sed -r -i "$sed_patterns" "$textfile" + done +@@ -439,6 +441,43 @@ + return 0 + } + ++ ++# Creation of TestResults file ++# Each line of the file contains TESTRESULT_VAR=$RESULT_VALUE ++# so the file can be sourced afterwards ++__INTERNAL_TestResultsSave(){ ++ # Set exit code of the test according to worst phase result ++ case "$__INTERNAL_PHASES_WORST_RESULT" in ++ PASS) ++ __TESTRESULT_RESULT_ECODE="0" ++ ;; ++ WARN) ++ __TESTRESULT_RESULT_ECODE="10" ++ ;; ++ FAIL) ++ __TESTRESULT_RESULT_ECODE="20" ++ ;; ++ *) ++ __TESTRESULT_RESULT_ECODE="30" ++ ;; ++ esac ++ ++ cat > "$__INTERNAL_TEST_RESULTS" < "$__INTERNAL_PRESISTENT_DATA" < "$__INTERNAL_PERSISTENT_DATA" <> $__INTERNAL_PRESISTENT_DATA +-declare -p __INTERNAL_PHASE_PASSED >> $__INTERNAL_PRESISTENT_DATA +-declare -p __INTERNAL_PHASE_STARTTIME >> $__INTERNAL_PRESISTENT_DATA +-declare -p __INTERNAL_PHASE_TXTLOG_START >> $__INTERNAL_PRESISTENT_DATA +-declare -p __INTERNAL_PHASE_METRICS >> $__INTERNAL_PRESISTENT_DATA ++declare -p __INTERNAL_PHASE_FAILED >> $__INTERNAL_PERSISTENT_DATA ++declare -p __INTERNAL_PHASE_PASSED >> $__INTERNAL_PERSISTENT_DATA ++declare -p __INTERNAL_PHASE_STARTTIME >> $__INTERNAL_PERSISTENT_DATA ++declare -p __INTERNAL_PHASE_TXTLOG_START >> $__INTERNAL_PERSISTENT_DATA ++declare -p __INTERNAL_PHASE_METRICS >> $__INTERNAL_PERSISTENT_DATA + } + + __INTERNAL_PersistentDataLoad() { +- [[ -r "$__INTERNAL_PRESISTENT_DATA" ]] && . "$__INTERNAL_PRESISTENT_DATA" ++ [[ -r "$__INTERNAL_PERSISTENT_DATA" ]] && . "$__INTERNAL_PERSISTENT_DATA" + } + + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +only in patch2: +unchanged: +--- a/src/beakerlib.sh ++++ b/src/beakerlib.sh +@@ -96,6 +96,48 @@ See the BKRDOC section for more information about Automated documentation genera + + =for comment beakerlib-manual-footer + ++=head1 OUTPUT FILES ++ ++Location of test results related output files can be configured by setting BEAKERLIB_DIR variable before running the test. If it is not set, temporary directory is created. ++ ++=head2 journal.txt ++ ++Journal in human readable form. ++ ++=head2 journal.xml ++ ++Journal in XML format, requires python. This dependency can be avoided if the test is run with variable BEAKERLIB_JOURNAL set to 0 in which case journal.xml is not created. ++ ++=head3 XSLT ++ ++XML journal can be transformed through XSLT template. Which template is used is configurable by setting BEAKERLIB_JOURNAL variable. Value can be either filename in which case beakerlib will try to use $INSTALL_DIR/xslt-template/$filename (e.g.: /usr/share/beakerlib/xstl-templates/xunit.xsl) or it can be path to a template anywhere on the system. ++ ++=head2 TestResults ++ ++Overall results of the test in a 'sourceable' form. Each line contains a pair VAR=VALUE. All variable names have 'TESTRESULT_' prefix. ++ ++=head3 List of variables: ++ ++TESTRESULT_RESULT_STRING - Result of the test in a string, e.g.: PASS, FAIL, WARN. ++ ++TESTRESULT_RESULT_ECODE - Result of the test as an integer, 0 equals to PASS. ++ ++TESTRESULT_PHASES_PASSED - Number of phases that ended with PASS. ++ ++TESTRESULT_PHASES_FAILED - Number of phases that ended with non-PASS result. ++ ++TESTRESULT_PHASES_SKIPPED - Number of skipped phases. ++ ++TESTRESULT_ASSERTS_FAILED - Number of asserts that ended with non-PASS result in the whole test. ++ ++TESTRESULT_STARTTIME - Time when test started in seconds since epoch. ++ ++TESTRESULT_ENDTIME - Time when test ended in seconds since epoch. ++ ++TESTRESULT_DURATION - Duration of the test run in seconds. ++ ++TESTRESULT_BEAKERLIB_DIR - Directory with test results files. ++ + =head1 EXAMPLES + + =head2 Simple diff --git a/var-TEST.patch b/var-TEST.patch new file mode 100644 index 0000000..8e29ab8 --- /dev/null +++ b/var-TEST.patch @@ -0,0 +1,41 @@ +From 30c5a9b8982e6342cfff28871083f36efc80f52b Mon Sep 17 00:00:00 2001 +From: Dalibor Pospisil +Date: Tue, 12 Dec 2017 14:34:35 +0100 +Subject: [PATCH 14/18] leave variable TEST intact + +--- + src/journal.sh | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +diff --git a/src/journal.sh b/src/journal.sh +index 092de14..8e68fb3 100644 +--- a/src/journal.sh ++++ b/src/journal.sh +@@ -432,9 +432,9 @@ rlJournalPrintText(){ + cat "$textfile" + + local __INTERNAL_LogText_no_file=1 +- __INTERNAL_PrintHeadLog "${TEST}" 2>&1 ++ __INTERNAL_PrintHeadLog "${__INTERNAL_TEST_NAME}" 2>&1 + __INTERNAL_LogText "Phases: $__INTERNAL_PHASES_PASSED good, $__INTERNAL_PHASES_FAILED bad" LOG 2>&1 +- __INTERNAL_LogText "RESULT: $TEST" $__INTERNAL_PHASES_WORST_RESULT 2>&1 ++ __INTERNAL_LogText "RESULT: $__INTERNAL_TEST_NAME" $__INTERNAL_PHASES_WORST_RESULT 2>&1 + + return 0 + } +@@ -779,9 +779,9 @@ __INTERNAL_CreateHeader(){ + __INTERNAL_LogText " Test duration : " 2> /dev/null + + # Test name +- TEST="${TEST:-unknown}" +- __INTERNAL_WriteToMetafile testname -- "${TEST}" +- __INTERNAL_LogText " Test name : ${TEST}" 2> /dev/null ++ __INTERNAL_TEST_NAME="${TEST:-unknown}" ++ __INTERNAL_WriteToMetafile testname -- "${__INTERNAL_TEST_NAME}" ++ __INTERNAL_LogText " Test name : ${__INTERNAL_TEST_NAME}" 2> /dev/null + + # OS release + local release=$(cat /etc/redhat-release) +-- +2.14.3 +