source/selftest/selftest.pl

   1 #!/usr/bin/perl
   2 # Bootstrap Samba and run a number of tests against it.
   3 # Copyright (C) 2005-2007 Jelmer Vernooij <jelmer@samba.org>
   4 # Published under the GNU GPL, v3 or later.
   5
   6 =pod
   7
   8 =head1 NAME
   9
  10 selftest - Samba test runner
  11
  12 =head1 SYNOPSIS
  13
  14 selftest --help
  15
  16 selftest [--srcdir=DIR] [--builddir=DIR] [--target=samba4|samba3|win|kvm] [--socket-wrapper] [--quick] [--exclude=FILE] [--include=FILE] [--one] [--prefix=prefix] [--immediate] [--testlist=FILE] [TESTS]
  17
  18 =head1 DESCRIPTION
  19
  20 A simple test runner. TESTS is a regular expression with tests to run.
  21
  22 =head1 OPTIONS
  23
  24 =over 4
  25
  26 =item I<--help>
  27
  28 Show list of available options.
  29
  30 =item I<--srcdir=DIR>
  31
  32 Source directory.
  33
  34 =item I<--builddir=DIR>
  35
  36 Build directory.
  37
  38 =item I<--prefix=DIR>
  39
  40 Change directory to run tests in. Default is 'st'.
  41
  42 =item I<--immediate>
  43
  44 Show errors as soon as they happen rather than at the end of the test run.
  45
  46 =item I<--target samba4|samba3|win|kvm>
  47
  48 Specify test target against which to run. Default is 'samba4'.
  49
  50 =item I<--quick>
  51
  52 Run only a limited number of tests. Intended to run in about 30 seconds on
  53 moderately recent systems.
  54
  55 =item I<--socket-wrapper>
  56
  57 Use socket wrapper library for communication with server. Only works
  58 when the server is running locally.
  59
  60 Will prevent TCP and UDP ports being opened on the local host but
  61 (transparently) redirects these calls to use unix domain sockets.
  62
  63 =item I<--expected-failures>
  64
  65 Specify a file containing a list of tests that are expected to fail. Failures for
  66 these tests will be counted as successes, successes will be counted as failures.
  67
  68 The format for the file is, one entry per line:
  69
  70 TESTSUITE-NAME.TEST-NAME
  71
  72 The reason for a test can also be specified, by adding a hash sign (#) and the reason
  73 after the test name.
  74
  75 =item I<--exclude>
  76
  77 Specify a file containing a list of tests that should be skipped. Possible
  78 candidates are tests that segfault the server, flip or don't end. The format of this file is the same as
  79 for the --expected-failures flag.
  80
  81 =item I<--include>
  82
  83 Specify a file containing a list of tests that should be run. Same format
  84 as the --exclude flag.
  85
  86 Not includes specified means all tests will be run.
  87
  88 =item I<--one>
  89
  90 Abort as soon as one test fails.
  91
  92 =item I<--testlist>
  93
  94 Load a list of tests from the specified location.
  95
  96 =back
  97
  98 =head1 ENVIRONMENT
  99
 100 =over 4
 101
 102 =item I<SMBD_VALGRIND>
 103
 104 =item I<TORTURE_MAXTIME>
 105
 106 =item I<VALGRIND>
 107
 108 =item I<TLS_ENABLED>
 109
 110 =item I<srcdir>
 111
 112 =back
 113
 114 =head1 LICENSE
 115
 116 selftest is licensed under the GNU General Public License L<http://www.gnu.org/licenses/gpl.html>.
 117
 118 =head1 AUTHOR
 119
 120 Jelmer Vernooij
 121
 122 =cut
 123
 124 use strict;
 125
 126 use FindBin qw($RealBin $Script);
 127 use File::Spec;
 128 use Getopt::Long;
 129 use POSIX;
 130 use Cwd qw(abs_path);
 131 use lib "$RealBin";
 132 use Subunit qw(parse_results);
 133 use SocketWrapper;
 134
 135 my $opt_help = 0;
 136 my $opt_target = "samba4";
 137 my $opt_quick = 0;
 138 my $opt_socket_wrapper = 0;
 139 my $opt_socket_wrapper_pcap = undef;
 140 my $opt_socket_wrapper_keep_pcap = undef;
 141 my $opt_one = 0;
 142 my $opt_immediate = 0;
 143 my $opt_expected_failures = undef;
 144 my @opt_exclude = ();
 145 my @opt_include = ();
 146 my $opt_verbose = 0;
 147 my $opt_image = undef;
 148 my $opt_testenv = 0;
 149 my $ldap = undef;
 150 my $opt_analyse_cmd = undef;
 151 my $opt_resetup_env = undef;
 152 my $opt_bindir = undef;
 153 my $opt_no_lazy_setup = undef;
 154 my $opt_format = "plain";
 155 my @testlists = ();
 156
 157 my $srcdir = ".";
 158 my $builddir = ".";
 159 my $prefix = "./st";
 160
 161 my @expected_failures = ();
 162 my @includes = ();
 163 my @excludes = ();
 164
 165 my $statistics = {
 166         SUITES_FAIL => 0,
 167
 168         TESTS_UNEXPECTED_OK => 0,
 169         TESTS_EXPECTED_OK => 0,
 170         TESTS_UNEXPECTED_FAIL => 0,
 171         TESTS_EXPECTED_FAIL => 0,
 172         TESTS_ERROR => 0,
 173         TESTS_SKIP => 0,
 174 };
 175
 176 sub find_in_list($$)
 177 {
 178         my ($list, $fullname) = @_;
 179
 180         foreach (@$list) {
 181                 if ($fullname =~ /$$_[0]/) {
 182                          return ($$_[1]) if ($$_[1]);
 183                          return "NO REASON SPECIFIED";
 184                 }
 185         }
 186
 187         return undef;
 188 }
 189
 190 sub expecting_failure($)
 191 {
 192         my ($name) = @_;
 193         return find_in_list(\@expected_failures, $name);
 194 }
 195
 196 sub skip($)
 197 {
 198         my ($name) = @_;
 199
 200         return find_in_list(\@excludes, $name);
 201 }
 202
 203 sub getlog_env($);
 204
 205 sub setup_pcap($)
 206 {
 207         my ($state, $name) = @_;
 208
 209         return unless ($opt_socket_wrapper_pcap);
 210         return unless defined($ENV{SOCKET_WRAPPER_PCAP_DIR});
 211
 212         my $fname = $name;
 213         $fname =~ s%[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\-]%_%g;
 214
 215         my $pcap_file = "$ENV{SOCKET_WRAPPER_PCAP_DIR}/$fname.pcap";
 216
 217         SocketWrapper::setup_pcap($pcap_file);
 218
 219         return $pcap_file;
 220 }
 221
 222 sub cleanup_pcap($$$)
 223 {
 224         my ($pcap_file, $expected_ret, $ret) = @_;
 225
 226         return unless ($opt_socket_wrapper_pcap);
 227         return if ($opt_socket_wrapper_keep_pcap);
 228         return unless ($expected_ret == $ret);
 229         return unless defined($pcap_file);
 230
 231         unlink($pcap_file);
 232 }
 233
 234 sub run_testsuite($$$$$$)
 235 {
 236         my ($envname, $name, $cmd, $i, $totalsuites, $msg_ops) = @_;
 237         my $pcap_file = setup_pcap($name);
 238
 239         $msg_ops->start_test([], $name);
 240
 241         open(RESULT, "$cmd 2>&1|");
 242         my $expected_ret = parse_results(
 243                 $msg_ops, $statistics, *RESULT, \&expecting_failure, [$name]);
 244
 245         my $envlog = getlog_env($envname);
 246         $msg_ops->output_msg("ENVLOG: $envlog\n") if ($envlog ne "");
 247
 248         $msg_ops->output_msg("CMD: $cmd\n");
 249
 250         my $ret = close(RESULT);
 251         $ret = 0 unless $ret == 1;
 252
 253         if ($ret == 1) {
 254                 $msg_ops->end_test([], $name, "success", $expected_ret != $ret, undef);
 255         } else {
 256                 $msg_ops->end_test([], $name, "failure", $expected_ret != $ret,
 257                                                "Returned $ret");
 258         }
 259
 260         cleanup_pcap($pcap_file, $expected_ret, $ret);
 261
 262         if (not $opt_socket_wrapper_keep_pcap and
 263                 defined($pcap_file)) {
 264                 $msg_ops->output_msg("PCAP FILE: $pcap_file\n");
 265         }
 266
 267         if ($ret != $expected_ret) {
 268                 $statistics->{SUITES_FAIL}++;
 269                 exit(1) if ($opt_one);
 270         }
 271
 272         return ($ret == $expected_ret);
 273 }
 274
 275 sub ShowHelp()
 276 {
 277         print "Samba test runner
 278 Copyright (C) Jelmer Vernooij <jelmer\@samba.org>
 279
 280 Usage: $Script [OPTIONS] PREFIX
 281
 282 Generic options:
 283  --help                     this help page
 284  --target=samba[34]|win|kvm Samba version to target
 285  --testlist=FILE                        file to read available tests from
 286
 287 Paths:
 288  --prefix=DIR               prefix to run tests in [st]
 289  --srcdir=DIR               source directory [.]
 290  --builddir=DIR             output directory [.]
 291
 292 Target Specific:
 293  --socket-wrapper-pcap          save traffic to pcap directories
 294  --socket-wrapper-keep-pcap keep all pcap files, not just those for tests that
 295                             failed
 296  --socket-wrapper           enable socket wrapper
 297  --expected-failures=FILE   specify list of tests that is guaranteed to fail
 298
 299 Samba4 Specific:
 300  --ldap=openldap|fedora-ds     back smbd onto specified ldap server
 301
 302 Samba3 Specific:
 303  --bindir=PATH              path to binaries
 304
 305 Kvm Specific:
 306  --image=PATH               path to KVM image
 307
 308 Behaviour:
 309  --quick                    run quick overall test
 310  --one                      abort when the first test fails
 311  --immediate                print test output for failed tests during run
 312  --verbose                  be verbose
 313  --analyse-cmd CMD          command to run after each test
 314 ";
 315         exit(0);
 316 }
 317
 318 my $result = GetOptions (
 319                 'help|h|?' => \$opt_help,
 320                 'target=s' => \$opt_target,
 321                 'prefix=s' => \$prefix,
 322                 'socket-wrapper' => \$opt_socket_wrapper,
 323                 'socket-wrapper-pcap' => \$opt_socket_wrapper_pcap,
 324                 'socket-wrapper-keep-pcap' => \$opt_socket_wrapper_keep_pcap,
 325                 'quick' => \$opt_quick,
 326                 'one' => \$opt_one,
 327                 'immediate' => \$opt_immediate,
 328                 'expected-failures=s' => \$opt_expected_failures,
 329                 'exclude=s' => \@opt_exclude,
 330                 'include=s' => \@opt_include,
 331                 'srcdir=s' => \$srcdir,
 332                 'builddir=s' => \$builddir,
 333                 'verbose' => \$opt_verbose,
 334                 'testenv' => \$opt_testenv,
 335                 'ldap:s' => \$ldap,
 336                 'analyse-cmd=s' => \$opt_analyse_cmd,
 337                 'no-lazy-setup' => \$opt_no_lazy_setup,
 338                 'resetup-environment' => \$opt_resetup_env,
 339                 'bindir:s' => \$opt_bindir,
 340                 'format=s' => \$opt_format,
 341                 'image=s' => \$opt_image,
 342                 'testlist=s' => \@testlists
 343             );
 344
 345 exit(1) if (not $result);
 346
 347 ShowHelp() if ($opt_help);
 348
 349 my $tests = shift;
 350
 351 # quick hack to disable rpc validation when using valgrind - its way too slow
 352 unless (defined($ENV{VALGRIND})) {
 353         $ENV{VALIDATE} = "validate";
 354         $ENV{MALLOC_CHECK_} = 2;
 355 }
 356
 357 my $old_pwd = "$RealBin/..";
 358
 359 # Backwards compatibility:
 360 if (defined($ENV{TEST_LDAP}) and $ENV{TEST_LDAP} eq "yes") {
 361         if (defined($ENV{FEDORA_DS_ROOT})) {
 362                 $ldap = "fedora-ds";
 363         } else {
 364                 $ldap = "openldap";
 365         }
 366 }
 367
 368 my $torture_maxtime = ($ENV{TORTURE_MAXTIME} or 1200);
 369 if ($ldap) {
 370         # LDAP is slow
 371         $torture_maxtime *= 2;
 372 }
 373
 374 $prefix =~ s+//+/+;
 375 $prefix =~ s+/./+/+;
 376 $prefix =~ s+/$++;
 377
 378 die("using an empty prefix isn't allowed") unless $prefix ne "";
 379
 380 #Ensure we have the test prefix around
 381 mkdir($prefix, 0777) unless -d $prefix;
 382
 383 my $prefix_abs = abs_path($prefix);
 384 my $srcdir_abs = abs_path($srcdir);
 385
 386 die("using an empty absolute prefix isn't allowed") unless $prefix_abs ne "";
 387 die("using '/' as absolute prefix isn't allowed") unless $prefix_abs ne "/";
 388
 389 $ENV{PREFIX} = $prefix;
 390 $ENV{KRB5CCNAME} = "$prefix/krb5ticket";
 391 $ENV{PREFIX_ABS} = $prefix_abs;
 392 $ENV{SRCDIR} = $srcdir;
 393 $ENV{SRCDIR_ABS} = $srcdir_abs;
 394
 395 if (defined($ENV{RUN_FROM_BUILD_FARM}) and
 396         ($ENV{RUN_FROM_BUILD_FARM} eq "yes")) {
 397         $opt_format = "buildfarm";
 398 }
 399
 400 my $tls_enabled = not $opt_quick;
 401 $ENV{TLS_ENABLED} = ($tls_enabled?"yes":"no");
 402 $ENV{LDB_MODULES_PATH} = "$old_pwd/bin/modules/ldb";
 403 $ENV{LD_SAMBA_MODULE_PATH} = "$old_pwd/bin/modules";
 404 if (defined($ENV{PKG_CONFIG_PATH})) {
 405         $ENV{PKG_CONFIG_PATH} = "$old_pwd/bin/pkgconfig:$ENV{PKG_CONFIG_PATH}";
 406 } else {
 407         $ENV{PKG_CONFIG_PATH} = "$old_pwd/bin/pkgconfig";
 408 }
 409 # Required for smbscript:
 410 $ENV{PATH} = "$old_pwd/bin:$old_pwd:$ENV{PATH}";
 411
 412 if ($opt_socket_wrapper_keep_pcap) {
 413         # Socket wrapper keep pcap implies socket wrapper pcap
 414         $opt_socket_wrapper_pcap = 1;
 415 }
 416
 417 if ($opt_socket_wrapper_pcap) {
 418         # Socket wrapper pcap implies socket wrapper
 419         $opt_socket_wrapper = 1;
 420 }
 421
 422 my $socket_wrapper_dir;
 423 if ($opt_socket_wrapper) {
 424         $socket_wrapper_dir = SocketWrapper::setup_dir("$prefix/w", $opt_socket_wrapper_pcap);
 425         print "SOCKET_WRAPPER_DIR=$socket_wrapper_dir\n";
 426 } else {
 427         warn("Not using socket wrapper, but also not running as root. Will not be able to listen on proper ports") unless $< == 0;
 428 }
 429
 430 my $target;
 431 my $testenv_default = "none";
 432
 433 if ($opt_target eq "samba4") {
 434         $testenv_default = "member";
 435         require target::Samba4;
 436         $target = new Samba4($opt_bindir or "$srcdir/bin", $ldap, "$srcdir/setup");
 437 } elsif ($opt_target eq "samba3") {
 438         if ($opt_socket_wrapper and `$opt_bindir/smbd -b | grep SOCKET_WRAPPER` eq "") {
 439                 die("You must include --enable-socket-wrapper when compiling Samba in order to execute 'make test'.  Exiting....");
 440         }
 441         $testenv_default = "dc";
 442         require target::Samba3;
 443         $target = new Samba3($opt_bindir);
 444 } elsif ($opt_target eq "win") {
 445         die("Windows tests will not run with socket wrapper enabled.")
 446                 if ($opt_socket_wrapper);
 447         $testenv_default = "dc";
 448         require target::Windows;
 449         $target = new Windows();
 450 } elsif ($opt_target eq "kvm") {
 451         die("Kvm tests will not run with socket wrapper enabled.")
 452                 if ($opt_socket_wrapper);
 453         require target::Kvm;
 454         die("No image specified") unless ($opt_image);
 455         $target = new Kvm($opt_image);
 456 }
 457
 458 sub read_test_regexes($)
 459 {
 460         my ($name) = @_;
 461         my @ret = ();
 462         open(LF, "<$name") or die("unable to read $name: $!");
 463         while (<LF>) {
 464                 chomp;
 465                 if (/^(.*?)([ \t]+)\#([\t ]*)(.*?)$/) {
 466                         push (@ret, [$1, $4]);
 467                 } else {
 468                         s/^(.*?)([ \t]+)\#([\t ]*)(.*?)$//;
 469                         push (@ret, [$_, undef]);
 470                 }
 471         }
 472         close(LF);
 473         return @ret;
 474 }
 475
 476 if (defined($opt_expected_failures)) {
 477         @expected_failures = read_test_regexes($opt_expected_failures);
 478 }
 479
 480 foreach (@opt_exclude) {
 481         push (@excludes, read_test_regexes($_));
 482 }
 483
 484 if ($opt_quick) {
 485         push (@includes, read_test_regexes("samba4-quick"));
 486 }
 487
 488 foreach (@opt_include) {
 489         push (@includes, read_test_regexes($_));
 490 }
 491
 492 my $interfaces = join(',', ("127.0.0.6/8",
 493                             "127.0.0.7/8",
 494                             "127.0.0.8/8",
 495                             "127.0.0.9/8",
 496                             "127.0.0.10/8",
 497                             "127.0.0.11/8"));
 498
 499 my $conffile = "$prefix_abs/client/client.conf";
 500
 501 sub write_clientconf($$)
 502 {
 503         my ($conffile, $vars) = @_;
 504
 505         mkdir("$prefix/client", 0777) unless -d "$prefix/client";
 506
 507         if ( -d "$prefix/client/private" ) {
 508                 unlink <$prefix/client/private/*>;
 509         } else {
 510                 mkdir("$prefix/client/private", 0777);
 511         }
 512
 513         open(CF, ">$conffile");
 514         print CF "[global]\n";
 515         if (defined($ENV{VALGRIND})) {
 516                 print CF "\ticonv:native = true\n";
 517         } else {
 518                 print CF "\ticonv:native = false\n";
 519         }
 520         print CF "\tnetbios name = client\n";
 521         if (defined($vars->{DOMAIN})) {
 522                 print CF "\tworkgroup = $vars->{DOMAIN}\n";
 523         }
 524         if (defined($vars->{REALM})) {
 525                 print CF "\trealm = $vars->{REALM}\n";
 526         }
 527         if (defined($vars->{NCALRPCDIR})) {
 528                 print CF "\tncalrpc dir = $vars->{NCALRPCDIR}\n";
 529         }
 530         if (defined($vars->{PIDDIR})) {
 531                 print CF "\tpid directory = $vars->{PIDDIR}\n";
 532         }
 533         if (defined($vars->{WINBINDD_SOCKET_DIR})) {
 534                 print CF "\twinbindd socket directory = $vars->{WINBINDD_SOCKET_DIR}\n";
 535         }
 536         print CF "
 537         private dir = $prefix_abs/client/private
 538         js include = $srcdir_abs/scripting/libjs
 539         name resolve order = bcast
 540         interfaces = $interfaces
 541         panic action = $srcdir_abs/script/gdb_backtrace \%PID\% \%PROG\%
 542         max xmit = 32K
 543         notify:inotify = false
 544         ldb:nosync = true
 545         system:anonymous = true
 546         torture:basedir = $prefix_abs/client
 547 #We don't want to pass our self-tests if the PAC code is wrong
 548         gensec:require_pac = true
 549         modules dir = $ENV{LD_SAMBA_MODULE_PATH}
 550 ";
 551         close(CF);
 552 }
 553
 554 my @torture_options = ();
 555 push (@torture_options, "--configfile=$conffile");
 556 # ensure any one smbtorture call doesn't run too long
 557 push (@torture_options, "--maximum-runtime=$torture_maxtime");
 558 push (@torture_options, "--target=$opt_target");
 559 push (@torture_options, "--basedir=$prefix_abs");
 560 push (@torture_options, "--option=torture:progress=no") if ($opt_format eq "buildfarm");
 561 push (@torture_options, "--format=subunit");
 562 push (@torture_options, "--option=torture:quick=yes") if ($opt_quick);
 563
 564 $ENV{TORTURE_OPTIONS} = join(' ', @torture_options);
 565 print "OPTIONS $ENV{TORTURE_OPTIONS}\n";
 566
 567 my @todo = ();
 568
 569 my $testsdir = "$srcdir/selftest";
 570 $ENV{SMB_CONF_PATH} = "$conffile";
 571 $ENV{CONFIGURATION} = "--configfile=$conffile";
 572
 573 my %required_envs = ();
 574
 575 sub read_testlist($)
 576 {
 577         my ($filename) = @_;
 578
 579         my @ret = ();
 580         open(IN, $filename) or die("Unable to open $filename: $!");
 581
 582         while (<IN>) {
 583                 if ($_ eq "-- TEST --\n") {
 584                         my $name = <IN>;
 585                         $name =~ s/\n//g;
 586                         my $env = <IN>;
 587                         $env =~ s/\n//g;
 588                         my $cmdline = <IN>;
 589                         $cmdline =~ s/\n//g;
 590                         if (not defined($tests) or $name =~ /$tests/) {
 591                                 $required_envs{$env} = 1;
 592                                 push (@ret, [$name, $env, $cmdline]);
 593                         }
 594                 } else {
 595                         print;
 596                 }
 597         }
 598         close(IN) or die("Error creating recipe");
 599         return @ret;
 600 }
 601
 602 if ($#testlists == -1) {
 603         die("No testlists specified");
 604 }
 605
 606 my @available = ();
 607 foreach my $fn (@testlists) {
 608         foreach (read_testlist($fn)) {
 609                 my $name = $$_[0];
 610                 next if (@includes and not find_in_list(\@includes, $name));
 611                 push (@available, $_);
 612         }
 613 }
 614
 615 my $msg_ops;
 616 if ($opt_format eq "buildfarm") {
 617         require output::buildfarm;
 618         $msg_ops = new output::buildfarm($statistics);
 619 } elsif ($opt_format eq "plain") {
 620         require output::plain;
 621         $msg_ops = new output::plain("$prefix/summary", $opt_verbose, $opt_immediate, $statistics, $#available+1);
 622 } elsif ($opt_format eq "html") {
 623         require output::html;
 624         mkdir("test-results", 0777);
 625         $msg_ops = new output::html("test-results", $statistics);
 626 } else {
 627         die("Invalid output format '$opt_format'");
 628 }
 629
 630
 631 foreach (@available) {
 632         my $name = $$_[0];
 633         my $skipreason = skip($name);
 634         if ($skipreason) {
 635                 $msg_ops->skip_testsuite($name, $skipreason);
 636         } else {
 637                 push(@todo, $_);
 638         }
 639 }
 640
 641 if ($#todo == -1) {
 642         print STDERR "No tests to run\n";
 643         exit(1);
 644         }
 645
 646 my $suitestotal = $#todo + 1;
 647 my $i = 0;
 648 $| = 1;
 649
 650 my %running_envs = ();
 651
 652 my @exported_envvars = (
 653         # domain stuff
 654         "DOMAIN",
 655         "REALM",
 656
 657         # domain controller stuff
 658         "DC_SERVER",
 659         "DC_SERVER_IP",
 660         "DC_NETBIOSNAME",
 661         "DC_NETBIOSALIAS",
 662
 663         # server stuff
 664         "SERVER",
 665         "SERVER_IP",
 666         "NETBIOSNAME",
 667         "NETBIOSALIAS",
 668
 669         # user stuff
 670         "USERNAME",
 671         "PASSWORD",
 672         "DC_USERNAME",
 673         "DC_PASSWORD",
 674
 675         # misc stuff
 676         "KRB5_CONFIG",
 677         "WINBINDD_SOCKET_DIR",
 678         "WINBINDD_PRIV_PIPE_DIR"
 679 );
 680
 681 $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
 682         my $signame = shift;
 683         teardown_env($_) foreach(keys %running_envs);
 684         die("Received signal $signame");
 685 };
 686
 687 sub setup_env($)
 688 {
 689         my ($envname) = @_;
 690
 691         my $testenv_vars;
 692         if ($envname eq "none") {
 693                 $testenv_vars = {};
 694         } elsif (defined($running_envs{$envname})) {
 695                 $testenv_vars = $running_envs{$envname};
 696                 if (not $target->check_env($testenv_vars)) {
 697                         $testenv_vars = undef;
 698                 }
 699         } else {
 700                 $testenv_vars = $target->setup_env($envname, $prefix);
 701         }
 702
 703         return undef unless defined($testenv_vars);
 704
 705         $running_envs{$envname} = $testenv_vars;
 706
 707         SocketWrapper::set_default_iface(6);
 708         write_clientconf($conffile, $testenv_vars);
 709
 710         foreach (@exported_envvars) {
 711                 if (defined($testenv_vars->{$_})) {
 712                         $ENV{$_} = $testenv_vars->{$_};
 713                 } else {
 714                         delete $ENV{$_};
 715                 }
 716         }
 717
 718         return $testenv_vars;
 719 }
 720
 721 sub exported_envvars_str($)
 722 {
 723         my ($testenv_vars) = @_;
 724         my $out = "";
 725
 726         foreach (@exported_envvars) {
 727                 next unless defined($testenv_vars->{$_});
 728                 $out .= $_."=".$testenv_vars->{$_}."\n";
 729         }
 730
 731         return $out;
 732 }
 733
 734 sub getlog_env($)
 735 {
 736         my ($envname) = @_;
 737         return "" if ($envname eq "none");
 738         return $target->getlog_env($running_envs{$envname});
 739 }
 740
 741 sub check_env($)
 742 {
 743         my ($envname) = @_;
 744         return 1 if ($envname eq "none");
 745         return $target->check_env($running_envs{$envname});
 746 }
 747
 748 sub teardown_env($)
 749 {
 750         my ($envname) = @_;
 751         return if ($envname eq "none");
 752         $target->teardown_env($running_envs{$envname});
 753         delete $running_envs{$envname};
 754 }
 755
 756 if ($opt_no_lazy_setup) {
 757         setup_env($_) foreach (keys %required_envs);
 758 }
 759
 760 if ($opt_testenv) {
 761         my $testenv_name = $ENV{SELFTEST_TESTENV};
 762         $testenv_name = $testenv_default unless defined($testenv_name);
 763
 764         my $testenv_vars = setup_env($testenv_name);
 765
 766         $ENV{PIDDIR} = $testenv_vars->{PIDDIR};
 767
 768         my $envvarstr = exported_envvars_str($testenv_vars);
 769
 770         my $term = ($ENV{TERM} or "xterm");
 771         system("$term -e 'echo -e \"
 772 Welcome to the Samba4 Test environment '$testenv_name'
 773
 774 This matches the client environment used in make test
 775 smbd is pid `cat \$PIDDIR/smbd.pid`
 776
 777 Some useful environment variables:
 778 TORTURE_OPTIONS=\$TORTURE_OPTIONS
 779 CONFIGURATION=\$CONFIGURATION
 780
 781 $envvarstr
 782 \" && LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH} bash'");
 783         teardown_env($testenv_name);
 784 } else {
 785         foreach (@todo) {
 786                 $i++;
 787                 my $cmd = $$_[2];
 788                 $cmd =~ s/([\(\)])/\\$1/g;
 789                 my $name = $$_[0];
 790                 my $envname = $$_[1];
 791
 792                 my $envvars = setup_env($envname);
 793                 if (not defined($envvars)) {
 794                         $msg_ops->skip_testsuite($name, "unable to set up environment $envname");
 795                         next;
 796                 }
 797
 798                 run_testsuite($envname, $name, $cmd, $i, $suitestotal,
 799                               $msg_ops);
 800
 801                 if (defined($opt_analyse_cmd)) {
 802                         system("$opt_analyse_cmd \"$name\"");
 803                 }
 804
 805                 teardown_env($envname) if ($opt_resetup_env);
 806         }
 807 }
 808
 809 print "\n";
 810
 811 teardown_env($_) foreach (keys %running_envs);
 812
 813 $target->stop();
 814
 815 $msg_ops->summary();
 816
 817 my $failed = 0;
 818
 819 # if there were any valgrind failures, show them
 820 foreach (<$prefix/valgrind.log*>) {
 821         next unless (-s $_);
 822         system("grep DWARF2.CFI.reader $_ > /dev/null");
 823         if ($? >> 8 == 0) {
 824             print "VALGRIND FAILURE\n";
 825             $failed++;
 826             system("cat $_");
 827         }
 828 }
 829
 830 if ($opt_format eq "buildfarm") {
 831         print "TEST STATUS: $statistics->{SUITES_FAIL}\n";
 832 }
 833
 834 exit $statistics->{SUITES_FAIL};