lib/VPIT/TestHelpers.pm

   1 package VPIT::TestHelpers;
   2
   3 use strict;
   4 use warnings;
   5
   6 use Config ();
   7
   8 sub export_to_pkg {
   9  my ($subs, $pkg) = @_;
  10
  11  while (my ($name, $code) = each %$subs) {
  12   no strict 'refs';
  13   *{$pkg.'::'.$name} = $code;
  14  }
  15
  16  return 1;
  17 }
  18
  19 my %default_exports = (
  20  load_or_skip     => \&load_or_skip,
  21  load_or_skip_all => \&load_or_skip_all,
  22  skip_all         => \&skip_all,
  23 );
  24
  25 my %features = (
  26  threads  => \&init_threads,
  27  usleep   => \&init_usleep,
  28  run_perl => \&init_run_perl,
  29  capture  => \&init_capture,
  30 );
  31
  32 sub import {
  33  shift;
  34  my @opts = @_;
  35
  36  my %exports = %default_exports;
  37
  38  for (my $i = 0; $i <= $#opts; ++$i) {
  39   my $feature = $opts[$i];
  40   next unless defined $feature;
  41
  42   my $args;
  43   if ($i < $#opts and defined $opts[$i+1] and ref $opts[$i+1] eq 'ARRAY') {
  44    ++$i;
  45    $args = $opts[$i];
  46   } else {
  47    $args = [ ];
  48   }
  49
  50   my $handler = $features{$feature};
  51   die "Unknown feature '$feature'" unless defined $handler;
  52
  53   my %syms = $handler->(@$args);
  54
  55   $exports{$_} = $syms{$_} for sort keys %syms;
  56  }
  57
  58  export_to_pkg \%exports => scalar caller;
  59 }
  60
  61 my $test_sub = sub {
  62  my $sub = shift;
  63
  64  my $stash;
  65  if ($INC{'Test/Leaner.pm'}) {
  66   $stash = \%Test::Leaner::;
  67  } else {
  68   require Test::More;
  69   $stash = \%Test::More::;
  70  }
  71
  72  my $glob = $stash->{$sub};
  73  return $glob ? *$glob{CODE} : undef;
  74 };
  75
  76 sub skip { $test_sub->('skip')->(@_) }
  77
  78 sub skip_all { $test_sub->('plan')->(skip_all => $_[0]) }
  79
  80 sub diag {
  81  my $diag = $test_sub->('diag');
  82  $diag->($_) for @_;
  83 }
  84
  85 our $TODO;
  86 local $TODO;
  87
  88 sub load {
  89  my ($pkg, $ver, $imports) = @_;
  90
  91  my $spec = $ver && $ver !~ /^[0._]*$/ ? "$pkg $ver" : $pkg;
  92  my $err;
  93
  94  local $@;
  95  if (eval "use $spec (); 1") {
  96   $ver = do { no strict 'refs'; ${"${pkg}::VERSION"} };
  97   $ver = 'undef' unless defined $ver;
  98
  99   if ($imports) {
 100    my @imports = @$imports;
 101    my $caller  = (caller 1)[0];
 102    local $@;
 103    my $res = eval <<"IMPORTER";
 104 package
 105         $caller;
 106 BEGIN { \$pkg->import(\@imports) }
 107 1;
 108 IMPORTER
 109    $err = "Could not import '@imports' from $pkg $ver: $@" unless $res;
 110   }
 111  } else {
 112   (my $file = "$pkg.pm") =~ s{::}{/}g;
 113   delete $INC{$file};
 114   $err = "Could not load $spec";
 115  }
 116
 117  if ($err) {
 118   return wantarray ? (0, $err) : 0;
 119  } else {
 120   diag "Using $pkg $ver";
 121   return 1;
 122  }
 123 }
 124
 125 sub load_or_skip {
 126  my ($pkg, $ver, $imports, $tests) = @_;
 127
 128  die 'You must specify how many tests to skip' unless defined $tests;
 129
 130  my ($loaded, $err) = load($pkg, $ver, $imports);
 131  skip $err => $tests unless $loaded;
 132
 133  return $loaded;
 134 }
 135
 136 sub load_or_skip_all {
 137  my ($pkg, $ver, $imports) = @_;
 138
 139  my ($loaded, $err) = load($pkg, $ver, $imports);
 140  skip_all $err unless $loaded;
 141
 142  return $loaded;
 143 }
 144
 145 sub fresh_perl_env (&) {
 146  my $handler = shift;
 147
 148  my ($SystemRoot, $PATH) = @ENV{qw<SystemRoot PATH>};
 149  my $ld_name  = $Config::Config{ldlibpthname};
 150  my $ldlibpth = $ENV{$ld_name};
 151
 152  local %ENV;
 153  $ENV{$ld_name}   = $ldlibpth   if                      defined $ldlibpth;
 154  $ENV{SystemRoot} = $SystemRoot if $^O eq 'MSWin32' and defined $SystemRoot;
 155  $ENV{PATH}       = $PATH       if $^O eq 'cygwin'  and defined $PATH;
 156
 157  my $perl = $^X;
 158  unless (-e $perl and -x $perl) {
 159   $perl = $Config::Config{perlpath};
 160   unless (-e $perl and -x $perl) {
 161    return undef;
 162   }
 163  }
 164
 165  return $handler->($perl, '-T', map("-I$_", @INC));
 166 }
 167
 168 sub init_run_perl {
 169  my $prefix = shift;
 170
 171  if (defined $prefix) {
 172   if (length $prefix and $prefix !~ /_$/) {
 173    $prefix .= '_';
 174   }
 175  } else {
 176   $prefix = '';
 177  }
 178
 179  my $p = $prefix;
 180
 181  return (
 182   run_perl              => \&run_perl,
 183   "${p}RUN_PERL_FAILED" => sub () { 'Could not execute perl subprocess' },
 184  );
 185 }
 186
 187 sub run_perl {
 188  my $code = shift;
 189
 190  if ($code =~ /"/) {
 191   die 'Double quotes in evaluated code are not portable';
 192  }
 193
 194  fresh_perl_env {
 195   my ($perl, @perl_args) = @_;
 196   system { $perl } $perl, @perl_args, '-e', $code;
 197  };
 198 }
 199
 200 sub init_capture {
 201  skip_all 'Cannot capture output on VMS' if $^O eq 'VMS';
 202
 203  load_or_skip_all 'IO::Handle', '0', [ ];
 204  load_or_skip_all 'IO::Select', '0', [ ];
 205  load_or_skip_all 'IPC::Open3', '0', [ ];
 206  if ($^O eq 'MSWin32') {
 207   load_or_skip_all 'Socket', '0', [ ];
 208  }
 209
 210  return (
 211   capture      => \&capture,
 212   capture_perl => \&capture_perl,
 213  );
 214 }
 215
 216 # Inspired from IPC::Cmd
 217
 218 sub capture {
 219  my @cmd = @_;
 220
 221  my $want = wantarray;
 222
 223  my $fail = sub {
 224   my $err     = $!;
 225   my $ext_err = $^O eq 'MSWin32' ? $^E : undef;
 226
 227   my $syscall = shift;
 228   my $args    = join ', ', @_;
 229
 230   my $msg = "$syscall($args) failed: ";
 231
 232   if (defined $err) {
 233    no warnings 'numeric';
 234    my ($err_code, $err_str) = (int $err, "$err");
 235    $msg .= "$err_str ($err_code)";
 236   }
 237
 238   if (defined $ext_err) {
 239    no warnings 'numeric';
 240    my ($ext_err_code, $ext_err_str) = (int $ext_err, "$ext_err");
 241    $msg .= ", $ext_err_str ($ext_err_code)";
 242   }
 243
 244   die "$msg\n";
 245  };
 246
 247  my ($status, $content_out, $content_err);
 248
 249  local $@;
 250  my $ok = eval {
 251   my ($pid, $out, $err);
 252
 253   if ($^O eq 'MSWin32') {
 254    my $pipe = sub {
 255     socketpair $_[0], $_[1],
 256                &Socket::AF_UNIX, &Socket::SOCK_STREAM, &Socket::PF_UNSPEC
 257                       or $fail->(qw<socketpair reader writer>);
 258     shutdown $_[0], 1 or $fail->(qw<shutdown reader>);
 259     shutdown $_[1], 0 or $fail->(qw<shutdown writer>);
 260     return 1;
 261    };
 262    local (*IN_R,  *IN_W);
 263    local (*OUT_R, *OUT_W);
 264    local (*ERR_R, *ERR_W);
 265    $pipe->(*IN_R,  *IN_W);
 266    $pipe->(*OUT_R, *OUT_W);
 267    $pipe->(*ERR_R, *ERR_W);
 268
 269    $pid = IPC::Open3::open3('>&IN_R', '<&OUT_W', '<&ERR_W', @cmd);
 270
 271    close *IN_W or $fail->(qw<close input>);
 272    $out = *OUT_R;
 273    $err = *ERR_R;
 274   } else {
 275    my $in = IO::Handle->new;
 276    $out   = IO::Handle->new;
 277    $out->autoflush(1);
 278    $err   = IO::Handle->new;
 279    $err->autoflush(1);
 280
 281    $pid = IPC::Open3::open3($in, $out, $err, @cmd);
 282
 283    close $in;
 284   }
 285
 286   # Forward signals to the child (except SIGKILL)
 287   my %sig_handlers;
 288   foreach my $s (keys %SIG) {
 289    $sig_handlers{$s} = sub {
 290     kill "$s" => $pid;
 291     $SIG{$s} = $sig_handlers{$s};
 292    };
 293   }
 294   local $SIG{$_} = $sig_handlers{$_} for keys %SIG;
 295
 296   unless ($want) {
 297    close $out or $fail->(qw<close output>);
 298    close $err or $fail->(qw<close error>);
 299    waitpid $pid, 0;
 300    $status = $?;
 301    return 1;
 302   }
 303
 304   my $sel = IO::Select->new();
 305   $sel->add($out, $err);
 306
 307   my $fd_out = fileno $out;
 308   my $fd_err = fileno $err;
 309
 310   my %contents;
 311   $contents{$fd_out} = '';
 312   $contents{$fd_err} = '';
 313
 314   while (my @ready = $sel->can_read) {
 315    for my $fh (@ready) {
 316     my $buf;
 317     my $bytes_read = sysread $fh, $buf, 4096;
 318     if (not defined $bytes_read) {
 319      $fail->('sysread', 'fd(' . fileno($fh) . ')');
 320     } elsif ($bytes_read) {
 321      $contents{fileno($fh)} .= $buf;
 322     } else {
 323      $sel->remove($fh);
 324      close $fh or $fail->('close', 'fd(' . fileno($fh) . ')');
 325      last unless $sel->count;
 326     }
 327    }
 328   }
 329
 330   waitpid $pid, 0;
 331   $status = $?;
 332
 333   if ($^O eq 'MSWin32') {
 334    # Manual CRLF translation that couldn't be done with sysread.
 335    s/\x0D\x0A/\n/g for values %contents;
 336   }
 337
 338   $content_out = $contents{$fd_out};
 339   $content_err = $contents{$fd_err};
 340
 341   1;
 342  };
 343
 344  if ($ok) {
 345   return ($status, $content_out, $content_err);
 346  } else {
 347   my $err = $@;
 348   chomp $err;
 349   return (undef, $err);
 350  }
 351 }
 352
 353 sub capture_perl {
 354  my $code = shift;
 355
 356  if ($code =~ /"/) {
 357   die 'Double quotes in evaluated code are not portable';
 358  }
 359
 360  fresh_perl_env {
 361   my @perl = @_;
 362   capture @perl, '-e', $code;
 363  };
 364 }
 365
 366 sub init_threads {
 367  my ($pkg, $threadsafe, $force_var) = @_;
 368
 369  skip_all 'This perl wasn\'t built to support threads'
 370                                             unless $Config::Config{useithreads};
 371
 372  $pkg = 'package' unless defined $pkg;
 373  skip_all "This $pkg isn't thread safe" if defined $threadsafe and !$threadsafe;
 374
 375  $force_var = 'PERL_FORCE_TEST_THREADS' unless defined $force_var;
 376  my $force  = $ENV{$force_var} ? 1 : !1;
 377  skip_all 'perl 5.13.4 required to test thread safety'
 378                                              unless $force or "$]" >= 5.013_004;
 379
 380  if (($INC{'Test/More.pm'} || $INC{'Test/Leaner.pm'}) && !$INC{'threads.pm'}) {
 381   die 'Test::More/Test::Leaner was loaded too soon';
 382  }
 383
 384  load_or_skip_all 'threads',         $force ? '0' : '1.67', [ ];
 385  load_or_skip_all 'threads::shared', $force ? '0' : '1.14', [ ];
 386
 387  require Test::Leaner;
 388
 389  diag "Threads testing forced by \$ENV{$force_var}" if $force;
 390
 391  return spawn => \&spawn;
 392 }
 393
 394 sub init_usleep {
 395  my $usleep;
 396
 397  if (do { local $@; eval { require Time::HiRes; 1 } }) {
 398   defined and diag "Using usleep() from Time::HiRes $_"
 399                                                       for $Time::HiRes::VERSION;
 400   $usleep = \&Time::HiRes::usleep;
 401  } else {
 402   diag 'Using fallback usleep()';
 403   $usleep = sub {
 404    my $s = int($_[0] / 2.5e5);
 405    sleep $s if $s;
 406   };
 407  }
 408
 409  return usleep => $usleep;
 410 }
 411
 412 sub spawn {
 413  local $@;
 414  my @diag;
 415  my $thread = eval {
 416   local $SIG{__WARN__} = sub { push @diag, "Thread creation warning: @_" };
 417   threads->create(@_);
 418  };
 419  push @diag, "Thread creation error: $@" if $@;
 420  diag @diag;
 421  return $thread ? $thread : ();
 422 }
 423
 424 package VPIT::TestHelpers::Guard;
 425
 426 sub new {
 427  my ($class, $code) = @_;
 428
 429  bless { code => $code }, $class;
 430 }
 431
 432 sub DESTROY { $_[0]->{code}->() }
 433
 434 1;