~drizzle-trunk/drizzle/development

#!/usr/bin/perl

#

# Copyright (C) 2008

# 

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; version 2 of the License.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

# 

# ======================================================================

#                     MySQL server stress test system 

# ======================================================================

#

##########################################################################

#

#                       SCENARIOS AND REQUIREMENTS

#

#   The system should perform stress testing of MySQL server with 

# following requirements and basic scenarios:

# 

# Basic requirements:

# 

# Design of stress script should allow one:

# 

#   - To stress test the mysqltest binary test engine.

#   - To stress test the regular test suite and any additional test suites

#     (such as mysql-test-extra-5.0).

#   - To specify files with lists of tests both for initialization of

#     stress db and for further testing itself.

#   - To define the number of threads to be concurrently used in testing.

#   - To define limitations for the test run. such as the number of tests or

#     loops for execution or duration of testing, delay between test

#     executions, and so forth.

#   - To get a readable log file that can be used for identification of

#     errors that occur during testing.

# 

# Basic scenarios:

# 

#     * It should be possible to run stress script in standalone mode

#       which will allow to create various scenarios of stress workloads:

# 

#       simple ones:

#

#         box #1:

#           - one instance of script with list of tests #1

# 

#       and more advanced ones:

# 

#         box #1:

#           - one instance of script with list of tests #1

#           - another instance of script with list of tests #2

#         box #2:

#           - one instance of script with list of tests #3

#           - another instance of script with list of tests #4

#             that will recreate whole database to back it to clean

#             state

# 

#       One kind of such complex scenarios maybe continued testing

#       when we want to run stress tests from many boxes with various

#       lists of tests that will last very long time. And in such case

#       we need some wrapper for MySQL server that will restart it in

#       case of crashes.

# 

#     * It should be possible to run stress script in ad-hoc mode from

#       shell or perl versions of mysql-test-run. This allows developers

#       to reproduce and debug errors that was found in continued stress 

#       testing

#

########################################################################

use Config;

if (!defined($Config{useithreads}))

{

  die <<EOF;

It is unable to run threaded version of stress test on this system 

due to disabled ithreads. Please check that installed perl binary 

was built with support of ithreads. 

EOF

}

use threads;

use threads::shared;

use IO::Socket;

use Sys::Hostname;

use File::Copy;

use File::Spec;

use File::Find;

use File::Basename;

use File::Path;

use Cwd;

use Data::Dumper;

use Getopt::Long;

my $stress_suite_version="1.0";

$|=1;

$opt_server_host="";

$opt_server_logs_dir="";

$opt_help="";

$opt_server_port="";

$opt_server_socket="";

$opt_server_user="";

$opt_server_password="";

$opt_server_database="";

$opt_cleanup="";

$opt_verbose="";

$opt_log_error_details="";

$opt_suite="main";

$opt_stress_suite_basedir="";

$opt_stress_basedir="";

$opt_stress_datadir="";

$opt_test_suffix="";

$opt_stress_mode="random";

$opt_loop_count=0;

$opt_test_count=0;

$opt_test_duration=0;

$opt_abort_on_error=0;

$opt_sleep_time = 0;

$opt_threads=1;

$pid_file="mysql_stress_test.pid";

$opt_mysqltest= ($^O =~ /mswin32/i) ? "mysqltest.exe" : "mysqltest";

$opt_check_tests_file="";

@mysqltest_args=("--silent", "-v");

# Client ip address

$client_ip=inet_ntoa((gethostbyname(hostname()))[4]);

$client_ip=~ s/\.//g;

%tests_files=(client => {mtime => 0, data => []},

              initdb => {mtime => 0, data => []});

# Error codes and sub-strings with corresponding severity 

#

# S1 - Critical errors - cause immediately abort of testing. These errors

#                        could be caused by server crash or impossibility

#                        of test execution

#

# S2 - Serious errors - these errors are bugs for sure as it knowns that 

#                       they shouldn't appear during stress testing  

#

# S3 - Non-seriuos errros - these errors could be caused by fact that 

#                           we execute simultaneously statements that

#                           affect tests executed by other threads

%error_strings = ( 'Failed in mysql_real_connect()' => S1,

                   'not found (Errcode: 2)' => S1 );

%error_codes = ( 1012 => S2, 1015 => S2, 1021 => S2,

                 1027 => S2, 1037 => S2, 1038 => S2,

                 1039 => S2, 1040 => S2, 1046 => S2, 

                 1180 => S2, 1181 => S2, 1203 => S2,

                 1205 => S2, 1206 => S2, 1207 => S2, 

                 1223 => S2, 2013 => S1);

share(%test_counters);

%test_counters=( loop_count => 0, test_count=>0);

share($exiting);

$exiting=0;

share($test_counters_lock);

$test_counters_lock=0;

share($log_file_lock);

$log_file_lock=0;

$SIG{INT}= \&sig_INT_handler;

$SIG{TERM}= \&sig_TERM_handler;

GetOptions("server-host=s", "server-logs-dir=s", "server-port=s",

           "server-socket=s", "server-user=s", "server-password=s",

           "server-database=s",

           "stress-suite-basedir=s", "suite=s", "stress-init-file:s", 

           "stress-tests-file:s", "stress-basedir=s", "stress-mode=s",

           "stress-datadir=s",

           "threads=s", "sleep-time=s", "loop-count=i", "test-count=i",

           "test-duration=i", "test-suffix=s", "check-tests-file", 

           "verbose", "log-error-details", "cleanup", "mysqltest=s", 

           "abort-on-error", "help") || usage();

usage() if ($opt_help);

#$opt_abort_on_error=1;

$test_dirname=get_timestamp();

$test_dirname.="-$opt_test_suffix" if ($opt_test_suffix ne '');

print <<EOF;

#############################################################

                  CONFIGURATION STAGE

#############################################################

EOF

if ($opt_stress_basedir eq '' || $opt_stress_suite_basedir eq '' ||

    $opt_server_logs_dir eq '')

{

  die <<EOF;

Options --stress-basedir, --stress-suite-basedir and --server-logs-dir are 

required. Please use these options to specify proper basedir for 

client, test suite and location of server logs.

stress-basedir: '$opt_stress_basedir'

stress-suite-basedir: '$opt_stress_suite_basedir'

server-logs-dir: '$opt_server_logs_dir'

EOF

}

#Workaround for case when we got relative but not absolute path 

$opt_stress_basedir=File::Spec->rel2abs($opt_stress_basedir);

$opt_stress_suite_basedir=File::Spec->rel2abs($opt_stress_suite_basedir);

$opt_server_logs_dir=File::Spec->rel2abs($opt_server_logs_dir);

if ($opt_stress_datadir ne '')

{

  $opt_stress_datadir=File::Spec->rel2abs($opt_stress_datadir);

}

if (! -d "$opt_stress_basedir")

{

  die <<EOF;

Directory '$opt_stress_basedir' does not exist.

Use --stress-basedir option to specify proper basedir for client

EOF

}

if (!-d $opt_stress_suite_basedir)

{

  die <<EOF;

Directory '$opt_stress_suite_basedir' does not exist.

Use --stress-suite-basedir option to specify proper basedir for test suite

EOF

}

$test_dataset_dir=$opt_stress_suite_basedir;

if ($opt_stress_datadir ne '')

{

  if (-d $opt_stress_datadir)

  {

    $test_dataset_dir=$opt_stress_datadir;

  }

  else

  {

    die <<EOF;

Directory '$opt_stress_datadir' not exists. Please specify proper one 

with --stress-datadir option.

EOF

  }  

}

if ($^O =~ /mswin32/i)

{

  $test_dataset_dir=~ s/\\/\\\\/g;

}

else

{

  $test_dataset_dir.="/";

}

if (!-d $opt_server_logs_dir)

{

  die <<EOF;

Directory server-logs-dir '$opt_server_logs_dir' does not exist.

Use --server-logs-dir option to specify proper directory for storing 

logs 

EOF

}

else

{

  #Create sub-directory for test session logs

  mkpath(File::Spec->catdir($opt_server_logs_dir, $test_dirname), 0, 0755);

  #Define filename of global session log file

  $stress_log_file=File::Spec->catfile($opt_server_logs_dir, $test_dirname,

                                       "mysql-stress-test.log");

}

if ($opt_suite ne '' && $opt_suite ne 'main' && $opt_suite ne 'default')

{

  $test_suite_dir=File::Spec->catdir($opt_stress_suite_basedir, "suite", $opt_suite);

}

else

{

  $test_suite_dir= $opt_stress_suite_basedir;

}

if (!-d $test_suite_dir)

{

  die <<EOF

Directory '$test_suite_dir' does not exist.

Use --suite options to specify proper dir for test suite

EOF

}

$test_suite_t_path=File::Spec->catdir($test_suite_dir,'t');

$test_suite_r_path=File::Spec->catdir($test_suite_dir,'r');

foreach my $suite_dir ($test_suite_t_path, $test_suite_r_path)

{

  if (!-d $suite_dir)

  {

    die <<EOF;

Directory '$suite_dir' does not exist.

Please ensure that you specified proper source location for 

test/result files with --stress-suite-basedir option and name 

of test suite with --suite option

EOF

  }

}

$test_t_path=File::Spec->catdir($opt_stress_basedir,'t');

$test_r_path=File::Spec->catdir($opt_stress_basedir,'r');

foreach $test_dir ($test_t_path, $test_r_path)

{

  if (-d $test_dir)

  {

    if ($opt_cleanup)

    {

      #Delete existing 't', 'r', 'r/*' subfolders in $stress_basedir

      rmtree("$test_dir", 0, 0);

      print "Cleanup $test_dir\n";

    }

    else

    {

      die <<EOF;

Directory '$test_dir' already exist. 

Please ensure that you specified proper location of working dir

for current test run with --stress-basedir option or in case of staled

directories use --cleanup option to remove ones

EOF

    }

  }

  #Create empty 't', 'r' subfolders that will be filled later

  mkpath("$test_dir", 0, 0777);

}

if (!defined($opt_stress_tests_file) && !defined($opt_stress_init_file))

{

  die <<EOF;

You should run stress script either with --stress-tests-file or with 

--stress-init-file otions. See help for details.

EOF

}

if (defined($opt_stress_tests_file))

{ 

  if ($opt_stress_tests_file eq '')

  {

    #Default location of file with set of tests for current test run

    $tests_files{client}->{filename}= File::Spec->catfile($opt_stress_suite_basedir,

                                      "testslist_client.txt");

  }

  else

  {

    $tests_files{client}->{filename}= $opt_stress_tests_file;

  }

  if (!-f $tests_files{client}->{filename})

  {

    die <<EOF;

File '$tests_files{client}->{filename}' with list of tests not exists. 

Please ensure that this file exists, readable or specify another one with 

--stress-tests-file option.

EOF

  }

}

if (defined($opt_stress_init_file))

{

  if ($opt_stress_init_file eq '')

  {

    #Default location of file with set of tests for current test run

    $tests_files{initdb}->{filename}= File::Spec->catfile($opt_stress_suite_basedir,

                                      "testslist_initdb.txt");

  }

  else

  {

    $tests_files{initdb}->{filename}= $opt_stress_init_file;

  }

  if (!-f $tests_files{initdb}->{filename})

  {

    die <<EOF;

File '$tests_files{initdb}->{filename}' with list of tests for initialization of database

for stress test not exists. 

Please ensure that this file exists, readable or specify another one with 

--stress-init-file option.

EOF

  }

}

if ($opt_stress_mode !~ /^(random|seq)$/)

{

  die <<EOF

Was specified wrong --stress-mode. Correct values 'random' and 'seq'.

EOF

}

if (open(TEST, "$opt_mysqltest -V |"))

{

  $mysqltest_version=join("",<TEST>);

  close(TEST);

  print "FOUND MYSQLTEST BINARY: ", $mysqltest_version,"\n";

}

else

{

  die <<EOF;

ERROR: mysqltest binary $opt_mysqltest not found $!.

You must either specify file location explicitly using --mysqltest

option, or make sure path to mysqltest binary is listed 

in your PATH environment variable.

EOF

}

#        

#Adding mysql server specific command line options for mysqltest binary

#

$opt_server_host= $opt_server_host ? $opt_server_host : "localhost";

$opt_server_port= $opt_server_port ? $opt_server_port : "4427";

$opt_server_user= $opt_server_user ? $opt_server_user : "root";

$opt_server_socket= $opt_server_socket ? $opt_server_socket : "/tmp/mysql.sock";

$opt_server_database= $opt_server_database ? $opt_server_database : "test";

unshift @mysqltest_args, "--host=$opt_server_host";

unshift @mysqltest_args, "--port=$opt_server_port";

unshift @mysqltest_args, "--user=$opt_server_user";

unshift @mysqltest_args, "--password=$opt_server_password";

unshift @mysqltest_args, "--socket=$opt_server_socket";

unshift @mysqltest_args, "--database=$opt_server_database";

#Export variables that could be used in tests

$ENV{DRIZZLE_TEST_DIR}=$test_dataset_dir;

$ENV{MASTER_MYPORT}=$opt_server_port;

$ENV{MASTER_MYSOCK}=$opt_server_socket;

print <<EOF;

TEST-SUITE-BASEDIR: $opt_stress_suite_basedir

SUITE:              $opt_suite

TEST-BASE-DIR:      $opt_stress_basedir

TEST-DATADIR:       $test_dataset_dir

SERVER-LOGS-DIR:    $opt_server_logs_dir

THREADS:            $opt_threads

TEST-MODE:          $opt_stress_mode

EOF

#-------------------------------------------------------------------------------

#At this stage we've already checked all needed pathes/files 

#and ready to start the test

#-------------------------------------------------------------------------------

if (defined($opt_stress_tests_file) || defined($opt_stress_init_file))

{

  print <<EOF;

#############################################################

                  PREPARATION STAGE

#############################################################

EOF

  #Copy Test files from network share to 't' folder

  print "\nCopying Test files from $test_suite_t_path to $test_t_path folder...";

  find({wanted=>\&copy_test_files, bydepth=>1}, "$test_suite_t_path");

  print "Done\n";

  #$test_r_path/r0 dir reserved for initdb

  $count_start= defined($opt_stress_init_file) ? 0 : 1;

  our $r_folder='';

  print "\nCreating 'r' folder and copying Protocol files to each 'r#' sub-folder...";

  for($count=$count_start; $count <= $opt_threads; $count++)

  {

    $r_folder = File::Spec->catdir($test_r_path, "r".$count);

    mkpath("$r_folder", 0, 0777); 

    find(\&copy_result_files,"$test_suite_r_path");

  }  

  print "Done\n\n";

}

if (defined($opt_stress_init_file))

{

  print <<EOF;

#############################################################

                  INITIALIZATION STAGE

#############################################################

EOF

  #Set limits for stress db initialization 

  %limits=(loop_count => 1, test_count => undef);

  #Read list of tests from $opt_stress_init_file

  read_tests_names($tests_files{initdb});

  test_loop($client_ip, 0, 'seq', $tests_files{initdb});  

  #print Dumper($tests_files{initdb}),"\n";

  print <<EOF;

Done initialization of stress database by tests from 

$tests_files{initdb}->{filename} file.

EOF

}

if (defined($opt_stress_tests_file))

{

  print <<EOF;

#############################################################

                  STRESS TEST RUNNING STAGE

#############################################################

EOF

  $exiting=0;

  #Read list of tests from $opt_stress_tests_file 

  read_tests_names($tests_files{client});

  #Reset current counter and set limits

  %test_counters=( loop_count => 0, test_count=>0);

  %limits=(loop_count => $opt_loop_count, test_count => $opt_test_count);

  if (($opt_loop_count && $opt_threads > $opt_loop_count) || 

      ($opt_test_count && $opt_threads > $opt_test_count))

  {

    warn <<EOF;

WARNING: Possible inaccuracies in number of executed loops or 

         tests because number of threads bigger than number of 

         loops or tests:

         Threads will be started: $opt_threads

         Loops will be executed:  $opt_loop_count

         Tests will be executed:  $opt_test_count    

EOF

  }

  #Create threads (number depending on the variable )

  for ($id=1; $id<=$opt_threads && !$exiting; $id++)

  {

    $thrd[$id] = threads->create("test_loop", $client_ip, $id,

                                 $opt_stress_mode, $tests_files{client});

    print "main: Thread ID $id TID ",$thrd[$id]->tid," started\n";

    select(undef, undef, undef, 0.5);

  }

  if ($opt_test_duration)

  {

    sleep($opt_test_duration);

    kill INT, $$;                             #Interrupt child threads

  }

  #Let other threads to process INT signal

  sleep(1);

  for ($id=1; $id<=$opt_threads;$id++)

  {

    if (defined($thrd[$id]))

    {

      $thrd[$id]->join();

    }

  }

  print "EXIT\n";

}

sub test_init

{

  my ($env)=@_;

  $env->{session_id}=$env->{ip}."_".$env->{thread_id};

  $env->{r_folder}='r'.$env->{thread_id}; 

  $env->{screen_logs}=File::Spec->catdir($opt_server_logs_dir, $test_dirname, 

                                         "screen_logs", $env->{session_id});

  $env->{reject_logs}=File::Spec->catdir($opt_server_logs_dir, $test_dirname,

                                         "reject_logs", $env->{session_id});

  mkpath($env->{screen_logs}, 0, 0755) unless (-d $env->{screen_logs});

  mkpath($env->{reject_logs}, 0, 0755) unless (-d $env->{reject_logs});

  $env->{session_log}= File::Spec->catfile($env->{screen_logs}, $env->{session_id}.".log");     

}

sub test_execute

{

  my $env= shift;

  my $test_name= shift;

  my $g_start= "";

  my $g_end= "";

  my $mysqltest_cmd= "";

  my @mysqltest_test_args=();

  my @stderr=();

  #Get time stamp

  $g_start = get_timestamp();

  $env->{errors}={};

  @{$env->{test_status}}=();

  my $test_file= $test_name.".test";

  my $result_file= $test_name.".result";

  my $reject_file = $test_name.'.reject';

  my $output_file = $env->{session_id}.'_'.$test_name.'_'.$g_start."_".$env->{test_count}.'.txt';

  my $test_filename = File::Spec->catfile($test_t_path, $test_file);

  my $result_filename = File::Spec->catdir($test_r_path, $env->{r_folder}, $result_file);

  my $reject_filename = File::Spec->catdir($test_r_path, $env->{r_folder}, $reject_file);

  my $output_filename = File::Spec->catfile($env->{screen_logs}, $output_file);     

  push @mysqltest_test_args, "--basedir=$opt_stress_suite_basedir/",

                             "--tmpdir=$opt_stress_basedir",

                             "-x $test_filename",

                             "-R $result_filename",

                             "2>$output_filename";

  $cmd= "$opt_mysqltest --no-defaults ".join(" ", @mysqltest_args)." ".

                                        join(" ", @mysqltest_test_args);

  system($cmd);

  $exit_value  = $? >> 8;

  $signal_num  = $? & 127;

  $dumped_core = $? & 128;

  my $tid= threads->self->tid;

  if (-s $output_filename > 0)

  { 

    #Read stderr for further analysis

    open (STDERR_LOG, $output_filename) or 

                             warn "Can't open file $output_filename";

    @stderr=<STDERR_LOG>;

    close(STDERR_LOG);

    if ($opt_verbose)

    {

      $session_debug_file="$opt_stress_basedir/error$tid.txt";

      stress_log($session_debug_file, 

                "Something wrong happened during execution of this command line:");

      stress_log($session_debug_file, "MYSQLTEST CMD - $cmd");    

      stress_log($session_debug_file, "STDERR:".join("",@stderr));      

      stress_log($session_debug_file, "EXIT STATUS:\n1. EXIT: $exit_value \n".

                                      "2. SIGNAL: $signal_num\n".

                                      "3. CORE: $dumped_core\n");

    }

  }

  #If something wrong trying to analyse stderr 

  if ($exit_value || $signal_num)

  {

    if (@stderr)

    {

      foreach my $line (@stderr)

      {

        #FIXME: we should handle case when for one sub-string/code 

        #       we have several different error messages        

        #       Now for both codes/substrings we assume that

        #       first found message will represent error

        #Check line for error codes

        if (($err_msg, $err_code)= $line=~/failed: ((\d+):.+?$)/)

        {

          if (!exists($error_codes{$err_code}))

          {

            $severity="S3";

            $err_code=0;

          }

          else

          {

            $severity=$error_codes{$err_code};

          }

          if (!exists($env->{errors}->{$severity}->{$err_code}))

          {

            $env->{errors}->{$severity}->{$err_code}=[0, $err_msg];

          }

          $env->{errors}->{$severity}->{$err_code}->[0]++;

          $env->{errors}->{$severity}->{total}++;          

        }

        #Check line for error patterns

        foreach $err_string (keys %error_strings)

        {

          $pattern= quotemeta $err_string;

          if ($line =~ /$pattern/i)

          {

            my $severity= $error_strings{$err_string};

            if (!exists($env->{errors}->{$severity}->{$err_string}))

            {

              $env->{errors}->{$severity}->{$err_string}=[0, $line];

            }

            $env->{errors}->{$severity}->{$err_string}->[0]++;

            $env->{errors}->{$severity}->{total}++;          

          }

        }

      }

    }

    else

    {

      $env->{errors}->{S3}->{'Unknown error'}=

                              [1,"Unknown error. Nothing was output to STDERR"];

      $env->{errors}->{S3}->{total}=1;

    }

  }

  #

  #FIXME: Here we can perform further analysis of recognized 

  #       error codes 

  #

  foreach my $severity (sort {$a cmp $b} keys %{$env->{errors}})

  {

    my $total=$env->{errors}->{$severity}->{total};

    if ($total)

    {

      push @{$env->{test_status}}, "Severity $severity: $total";

      $env->{errors}->{total}=+$total;

    }

  }

  #FIXME: Should we take into account $exit_value here?

  #       Now we assume that all stringified errors(i.e. errors without 

  #       error codes) which are not exist in %error_string structure 

  #       are OK

  if (!$env->{errors}->{total})

  {

    push @{$env->{test_status}},"No Errors. Test Passed OK";

  }

  log_session_errors($env, $test_file);

  if (!$exiting && ($signal_num == 2 || $signal_num == 15 || 

      ($opt_abort_on_error && $env->{errors}->{S1} > 0)))

  {

    #mysqltest was interrupted with INT or TERM signals or test was 

    #ran with --abort-on-error option and we got errors with severity S1

    #so we assume that we should cancel testing and exit

    $exiting=1;

    print STDERR<<EOF;

WARNING:

   mysqltest was interrupted with INT or TERM signals or test was 

   ran with --abort-on-error option and we got errors with severity S1

   (test cann't connect to the server or server crashed) so we assume that 

   we should cancel testing and exit. Please check log file for this thread 

   in $stress_log_file or 

   inspect below output of the last test case executed with mysqltest to 

   find out cause of error.

   Output of mysqltest:

   @stderr

EOF

  }

  if (-e $reject_filename)

  {  

    move_to_logs($env->{reject_logs}, $reject_filename, $reject_file);

  }    

  if (-e $output_filename)

  {  

    move_to_logs($env->{screen_logs}, $output_filename, $output_file);

  }    

}

sub test_loop

{     

  my %client_env=();

  my $test_name="";

  # KEY for session identification: IP-THREAD_ID

  $client_env{ip} = shift;

  $client_env{thread_id} = shift;

  $client_env{mode} = shift;

  $client_env{tests_file}=shift; 

  $client_env{test_seq_idx}=0;

  #Initialize session variables

  test_init(\%client_env);

LOOP:

  while(!$exiting)

  {

    if ($opt_check_tests_file)

    {

      #Check if tests_file was modified and reread it in this case

      read_tests_names($client_env{tests_file}, 0);

    }

    {

      lock($test_counters_lock);

      if (($limits{loop_count} && $limits{loop_count} <= $test_counters{loop_count}*1) ||

          ($limits{test_count} && $limits{test_count} <= $test_counters{test_count}*1) )

      {

        $exiting=1;

        next LOOP;

      }

    }

    #Get random file name 

    if (($test_name = get_test(\%client_env)) ne '')

    {

      {

        lock($test_counters_lock);

        #Save current counters values 

        $client_env{loop_count}=$test_counters{loop_count};

        $client_env{test_count}=$test_counters{test_count};

      }

      #Run test and analyze results

      test_execute(\%client_env, $test_name);

      print "test_loop[".$limits{loop_count}.":".

             $limits{test_count}." ".

             $client_env{loop_count}.":".

             $client_env{test_count}."]:".

             " TID ".$client_env{thread_id}.

             " test: '$test_name' ".

             " Errors: ".join(" ",@{$client_env{test_status}}),"\n";

      print "\n";

    }