view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

Changes
lib/Alt/Devel/GlobalDestruction/XS/Inline.pm
lib/Devel/GlobalDestruction/XS.c
lib/Devel/GlobalDestruction/XS.pm
lib/Devel/GlobalDestruction/XS/Inline.pm
Makefile.PL
MANIFEST			This list of files
t/01_basic.t
t/02_thread.t
t/03_minusc.t
t/04_phases.t
t/05_thread_clone.t
META.yml                                 Module YAML meta-data (added by MakeMaker)
META.json                                Module JSON meta-data (added by MakeMaker)
inc/Devel/GlobalDestruction/XS/Inline.pm
inc/Inline.pm
inc/Inline/denter.pm
inc/Inline/Module.pm
inc/Inline/C.pm
inc/Inline/C/Parser/RegExp.pm

t/02_thread.t  view on Meta::CPAN

use Config;
BEGIN {
  unless ($Config{useithreads}) {
    print "1..0 # SKIP your perl does not support ithreads\n";
    exit 0;
  }
}

BEGIN {
  unless (eval { require threads }) {
    print "1..0 # SKIP threads.pm not installed\n";
    exit 0;
  }
}

use threads;
use threads::shared;

our $had_error :shared;
END { $? = $had_error||0 }

use strict;
use warnings;

# load it before spawning a thread, that's the whole point
require Devel::GlobalDestruction::XS;

sub do_test {

  # just die so we don't need to deal with testcount skew
  unless ( ($_[0]||'') eq 'arg' ) {
    $had_error++;
    die "Argument passing failed!";
  }

  delete $INC{'t/01_basic.t'};
  do 't/01_basic.t';

  1;
}

threads->create('do_test', 'arg')->join
  or $had_error++;

t/05_thread_clone.t  view on Meta::CPAN

use strict;
use warnings;

use Config;
BEGIN {
  unless ($Config{useithreads}) {
    print "1..0 # SKIP your perl does not support ithreads\n";
    exit 0;
  }
}

BEGIN {
  unless (eval { require threads }) {
    print "1..0 # SKIP threads.pm not installed\n";
    exit 0;
  }
}

BEGIN {
  package Test::Scope::Guard;
  sub new { my ($class, $code) = @_; bless [$code], $class; }
  sub DESTROY { my $self = shift; $self->[0]->() }
}
BEGIN {
  package Test::Thread::Clone;
  my @code;
  sub new { my ($class, $code) = @_; push @code, $code; bless [$code], $class; }
  sub CLONE { $_->() for @code }
}

use threads;
use threads::shared;

print "1..4\n";

our $had_error :shared;
END { $? = $had_error||0 }

sub ok ($$) {
  $had_error++, print "not " if !$_[0];
  print "ok";
  print " - $_[1]" if defined $_[1];
  print "\n";
}

# load it before spawning a thread, that's the whole point
use Devel::GlobalDestruction::XS;

our $cloner = Test::Thread::Clone->new(sub {
    ok( ! Devel::GlobalDestruction::XS::in_global_destruction(), "CLONE is not GD" );
    my $guard = Test::Scope::Guard->new(sub {
        ok( ! Devel::GlobalDestruction::XS::in_global_destruction(), "DESTROY during CLONE is not GD");
    });
});
our $global = Test::Scope::Guard->new(sub {
    ok( Devel::GlobalDestruction::XS::in_global_destruction(), "Final cleanup object destruction properly in GD in " . (threads->tid ? 'thread' : 'main program') );
});

sub do_test {
  # just die so we don't need to deal with testcount skew
  unless ( ($_[0]||'') eq 'arg' ) {
    $had_error++;
    die "Argument passing failed!";
  }
  # nothing really to do in here
  1;
}

threads->create('do_test', 'arg')->join
  or $had_error++;