#########################
###use Data::Dumper ; print Dumper( $world ) ;
use Test;
BEGIN { plan tests => 89 } ;
use Safe::World ;
use strict ;
use warnings qw'all' ;
$|=1;
#########################
{
my $tmp ;
my $world_cache = Safe::World->new(
is_cache => 1 ,
stdout => \$tmp ,
stderr => \$tmp ,
no_io => 1 ,
flush => 1 ,
sharepack => ['foo'] ,
) ;
$world_cache->eval(q`
$GLOBAL = 'cache' ;
package foo ;
sub test { print STDOUT "TEST>> @_ [ $main::GLOBAL ]" ; }
`) ;
my $val0 = $world_cache->eval(q`$GLOBAL`) ;
###########
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->link_world($world_cache) ;
$world->eval(q`
$GLOBAL = 'world1' ;
foo::test(123) ;
`) ;
my $world_val = $world->eval(q`$GLOBAL`) ;
$world->unlink_world($world_cache) ;
$world->close ;
$world = undef ;
my $val = $world_cache->eval(q`$GLOBAL`) ;
ok($val0 , 'cache') ;
ok($world_val , 'world1') ;
ok($val , 'cache') ;
ok($stdout , 'TEST>> 123 [ world1 ]') ;
ok($stderr , '') ;
ok($tmp , undef) ;
}
#########################
{
my $tmp ;
my $world_cache = Safe::World->new(
is_cache => 1 ,
stdout => \$tmp ,
stderr => \$tmp ,
no_io => 1 ,
flush => 1 ,
sharepack => ['foo'] ,
) ;
$world_cache->eval(q`
package bar ;
$GLOBAL = 'cache' ;
package foo ;
sub test { print STDOUT "TEST>> @_ [ $bar::GLOBAL ]" ; }
`) ;
$world_cache->track_vars( qw($bar::GLOBAL) ) ;
my $val0 = $world_cache->eval(q`$bar::GLOBAL`) ;
###########
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->link_world($world_cache) ;
$world->eval(q`
$bar::GLOBAL = 'world1' ;
foo::test(123) ;
`) ;
my $world_val = $world->eval(q`$bar::GLOBAL`) ;
$world->unlink_world($world_cache) ;
$world->close ;
$world = undef ;
my $val = $world_cache->eval(q`$bar::GLOBAL`) ;
ok($val0 , 'cache') ;
ok($world_val , 'world1') ;
ok($val , 'cache') ;
ok($stdout , 'TEST>> 123 [ world1 ]') ;
ok($stderr , '') ;
ok($tmp , undef) ;
}
#########################
{
my $tmp ;
my $world_cache = Safe::World->new(
is_cache => 1 ,
stdout => \$tmp ,
stderr => \$tmp ,
no_io => 1 ,
flush => 1 ,
sharepack => ['foo'] ,
) ;
###########
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->link_world($world_cache) ;
$world_cache->track_vars( $world , qw($GLOBAL :defaults) ) ;
$world->eval(q`
package foo ;
sub test { print "TEST>> @_ [ $main::GLOBAL ]" ; }
`) ;
$world->eval(q`
$GLOBAL = 'world1' ;
foo::test(123) ;
`) ;
$world->unlink_world($world_cache) ;
$world->close ;
$world = undef ;
###########
my ( $stdout2 , $stderr2 ) = () ;
$world = Safe::World->new(
stdout => \$stdout2 ,
stderr => \$stderr2 ,
flush => 1 ,
) ;
$world->link_world($world_cache) ;
$world->eval(q`
$GLOBAL = 'world2' ;
foo::test(456) ;
`) ;
$world->unlink_world($world_cache) ;
$world->close ;
$world = undef ;
###########
ok($stdout , 'TEST>> 123 [ world1 ]') ;
ok($stderr , '') ;
ok($stdout2 , 'TEST>> 456 [ world2 ]') ;
ok($stderr2 , '') ;
}
#########################
{
my $tmp ;
my $world_cache = Safe::World->new(
is_cache => 1 ,
stdout => \$tmp ,
stderr => \$tmp ,
flush => 1 ,
no_set_safeworld => 1 ,
no_strict => 1 ,
) ;
my ( $stdout , $stderr , $headout ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
headout => \$headout ,
no_strict => 1,
headsplitter => 'HTML' ,
autohead => 1 ,
on_closeheaders => sub {
my ( $pack , $headers ) = @_ ;
$pack->print_stdout("[[$headers]]") ;
$pack->headers('') ;
return 1 ;
} ,
) ;
$| = 0 ;
use Safe::World::Scope ;
my $SCOPE_Safe_World ;
sub Safe::World::use_cached {
my $this = shift ;
my $module = shift ;
$SCOPE_Safe_World->call_hole('_use_cached_call_hole',$world,$world_cache,$module) ;
}
sub Safe::World::_use_cached_call_hole {
my $world = shift ;
my $world_cache = shift ;
my $module = shift ;
my $pm = $module ;
$pm =~ s/::/\//g ; $pm .= '.pm' ;
my ( $link_pack , $inc ) = $world_cache->use_shared($module) ;
if ( $link_pack && !ref($link_pack) ) {
warn($link_pack) ;
return ;
}
my $inside = $world->{INSIDE} ;
$world->{INSIDE} = undef ;
if ( ref($link_pack) eq 'ARRAY' ) {
foreach my $link_pack_i ( @$link_pack ) {
$world->link_pack($link_pack_i) ;
}
}
if ( ref($inc) eq 'HASH' ) {
foreach my $Key ( keys %$inc ) { $INC{$Key} = $$inc{$Key} ;}
}
$world->{INSIDE} = $inside ;
return 1 ;
}
$SCOPE_Safe_World = new Safe::World::Scope('Safe::World',1) ;
$world->print_header("X-Powered-By: Safe::World\n") ;
$world->print_header("Content-type: text/html\n\n") ;
$world->eval(q`
$SAFEWORLD->use_cached('Data::Dumper') ;
`);
$world->eval(q`
my @inc = (
'Carp.pm=' . ( $INC{'Carp.pm'} eq '#shared#' ? 1 : 0 ) ,
'Exporter.pm=' . ( $INC{'Exporter.pm'} eq '#shared#' ? 1 : 0 ) ,
'Data/Dumper.pm=' . ( $INC{'Data/Dumper.pm'} eq '#shared#' ? 1 : 0 ) ,
'XSLoader.pm=' . ( $INC{'XSLoader.pm'} eq '#shared#' ? 1 : 0 ) ,
'warnings/register.pm=' . ( $INC{'warnings/register.pm'} eq '#shared#' ? 1 : 0 ) ,
'warnings.pm=' . ( $INC{'warnings.pm'} eq '#shared#' ? 1 : 0 ) ,
'overload.pm=' . ( $INC{'overload.pm'} eq '#shared#' ? 1 : 0 ) ,
) ;
print Data::Dumper::Dumper( \@inc ) ;
`);
$world->close ;
$world = undef ;
$stdout =~ s/\n[ \t]*/\n/gs ;
ok ($stdout , q`[[X-Powered-By: Safe::World
Content-type: text/html
]]$VAR1 = [
'Carp.pm=1',
'Exporter.pm=1',
'Data/Dumper.pm=1',
'XSLoader.pm=1',
'warnings/register.pm=1',
'warnings.pm=1',
'overload.pm=1'
];
`) ;
ok($stderr , '') ;
ok($headout , '') ;
}
#########################
{
my ( $stdout , $stderr , $headout ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
headout => \$headout ,
no_strict => 1,
headsplitter => 'HTML' ,
autohead => 1 ,
on_closeheaders => sub {
my ( $pack , $headers ) = @_ ;
$pack->print_stdout("[[$headers]]") ;
$pack->headers('') ;
return 1 ;
} ,
) ;
$| = 0 ;
$world->print_header("X-Powered-By: Safe::World\n") ;
$world->print_header("Content-type: text/html\n\n") ;
$world->eval(q`
print "<pre>\n\n" ;
$|=1;
my $sel = select ;
print "content2 $sel\n" ;
my $sel = select ;
print "</pre>\n" ;
`);
$world->close ;
$world = undef ;
$stdout =~ s/SAFEWORLD\d+::STDOUT/main::STDOUT/gs ;
ok($stdout , q`[[X-Powered-By: Safe::World
Content-type: text/html
]]<pre>
content2 main::STDOUT
</pre>
`);
ok($stderr , '') ;
ok($headout , '') ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
env => {
FOO => 'bar' ,
BAZ => 'BRAS' ,
} ,
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
print "Test1 " ;
print STDERR "ERROR!\n" ;
warn("Alert!!!") ;
foreach my $Key (sort keys %ENV ) {
print "<$Key = $ENV{$Key}>" ;
}
`);
$stderr =~ s/eval \d+/eval x/gi ;
ok($stdout , "Test1 <BAZ = BRAS><FOO = bar>") ;
ok($stderr , "ERROR!\nAlert!!! at (eval x) line 4.\n") ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
$var = 'abcd' ;
$var{k1} = 'v1' ;
`);
my $val = $world->get('$var') ;
ok($val,'abcd');
$val = $world->get('$var{k1}') ;
ok($val,'v1');
my $var_ref = $world->get_ref('$var') ;
ok(ref($var_ref) , 'SCALAR');
${$var_ref} .= 'efgh' ;
$val = $world->get('$var') ;
ok($val,'abcdefgh');
my $var_ref_copy = $world->get_ref_copy('$var') ;
ok(ref($var_ref_copy) , 'SCALAR');
${$var_ref_copy} .= 'ijkl' ;
ok(${$var_ref_copy} ,'abcdefghijkl') ;
$val = $world->get('$var') ;
ok($val,'abcdefgh');
ok($stderr , '') ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
use strict ;
my @inc = sort keys %INC ;
print "\@INC: $#INC\n" if @INC ;
print "%INC: @inc\n" ;
`);
$stdout =~ s/\@INC: \d+/\@INC: x/ ;
ok($stdout , "\@INC: x\n\%INC: strict.pm\n");
ok($stderr , '') ;
}
#########################
{
my ( $stdout0 , $stderr0 ) ;
my $world = Safe::World->new(
stdout => \$stdout0 ,
stderr => \$stderr0 ,
) ;
$world->eval(q`
print "test0\n" ;
`);
$world->close ;
my ( $stdout1 , $stderr1 ) ;
$world->reset(
stdout => \$stdout1 ,
stderr => \$stderr1 ,
) ;
$world->eval(q`
print "test1\n" ;
`);
$world->close ;
ok($stdout0 , "test0\n");
ok($stderr0 , '') ;
ok($stdout1 , "test1\n");
ok($stderr1 , '') ;
}
#########################
{
my ( $stdout0 , $stderr0 ) ;
my $world = Safe::World->new(
stdout => \$stdout0 ,
stderr => \$stderr0 ,
flush => 1,
) ;
$world->eval(q`
print "test0\n" ;
warn("alert0");
`);
my ( $stdout1 , $stderr1 ) ;
$world->reset_output(
stdout => \$stdout1 ,
stderr => \$stderr1 ,
) ;
$world->eval(q`
print "test1\n" ;
warn("alert1");
`);
$world->close ;
ok($stdout0 , "test0\n");
ok($stderr0 =~ /^alert0[^\r\n]*$/) ;
ok($stdout1 , "test1\n");
ok($stderr1 =~ /^alert1[^\r\n]*$/s) ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
sub test { print "SUBTEST <@_> " ; }
`);
$world->eval(q`
&test ;
test(123,456) ;
test ;
`);
$world->call('test','outside');
ok($stdout , "SUBTEST <> SUBTEST <123 456> SUBTEST <> SUBTEST <outside> ");
ok($stderr , '') ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
use test::shared ;
my @incs = sort keys %INC ;
print "incs> @incs\n" ;
`);
$world = undef ;
ok($stdout , "incs> strict.pm test/shared.pm\n");
}
#########################
{
my ( $stdout0 , $stderr0 ) ;
my $world0 = Safe::World->new(
stdout => \$stdout0 ,
stderr => \$stderr0 ,
flush => 1 ,
) ;
$world0->eval(q`
use test::shared ;
my @incs = sort keys %INC ;
print "incs> @incs\n" ;
$TEST = 'w0' ;
print ">> $test::shared::VAR\n" ;
test::shared::method(0) ;
`);
my ( $stdout1 , $stderr1 ) ;
my $world1 = Safe::World->new(
stdout => \$stdout1 ,
stderr => \$stderr1 ,
flush => 1 ,
) ;
$world1->link_pack("$world0->{ROOT}::test::shared") ;
$world1->eval(q`
my @incs = sort keys %INC ;
print "incs> @incs\n" ;
$TEST = 'w1' ;
print ">> $test::shared::VAR\n" ;
test::shared::method(1) ;
`);
my ( $stdout2 , $stderr2 ) ;
my $world2 = Safe::World->new(
stdout => \$stdout2 ,
stderr => \$stderr2 ,
flush => 1 ,
) ;
$world2->link_pack("$world0->{ROOT}::test::shared") ;
$world2->eval(q`
my @incs = sort keys %INC ;
print "incs> @incs\n" ;
$TEST = 'w2' ;
print ">> $test::shared::VAR\n" ;
test::shared::method(2) ;
`);
ok($stdout0 , "incs> strict.pm test/shared.pm\n>> foovar\nSHARED[1]! [w0][w0] <<0>>\n");
ok($stderr0 , '') ;
ok($stdout1 , "incs> strict.pm\n>> foovar\nSHARED[2]! [w0][w1] <<1>>\n");
ok($stderr1 , '') ;
ok($stdout2 , "incs> strict.pm\n>> foovar\nSHARED[3]! [w0][w2] <<2>>\n");
ok($stderr2 , '') ;
ok($INC{'test/shared.pm'} , undef) ;
}
#########################
{
my ( $stdout0 , $stderr0 ) ;
my $world0 = Safe::World->new(
stdout => \$stdout0 ,
stderr => \$stderr0 ,
flush => 1 ,
) ;
$world0->eval(q`
use test::shared ;
my @incs = sort keys %INC ;
print "incs> @incs\n" ;
$TEST = 'w0' ;
print ">> $test::shared::VAR\n" ;
test::shared::method(0) ;
`);
$world0->set_sharedpack('test::shared') ;
my ( $stdout1 , $stderr1 ) ;
my $world1 = Safe::World->new(
stdout => \$stdout1 ,
stderr => \$stderr1 ,
flush => 1 ,
) ;
my $lnk = $world1->link_world($world0) ;
ok($lnk,1) ;
ok($world0->{WORLD_SHARED}[0], $world1->{ROOT}) ;
$world1->eval(q`
my @incs = sort keys %INC ;
print "incs> @incs >> $INC{'test/shared.pm'}\n" ;
$TEST = 'w1' ;
print ">> $test::shared::VAR\n" ;
test::shared::method(1) ;
`);
$world1->unlink_world($world0) ;
my ( $stdout2 , $stderr2 ) ;
my $world2 = Safe::World->new(
stdout => \$stdout2 ,
stderr => \$stderr2 ,
flush => 1 ,
) ;
$lnk = $world2->link_world($world0) ;
ok($lnk,1) ;
ok($world0->{WORLD_SHARED}[0], $world2->{ROOT}) ;
$world2->eval(q`
my @incs = sort keys %INC ;
print "incs> @incs >> $INC{'test/shared.pm'}\n" ;
$TEST = 'w2' ;
print ">> $test::shared::VAR\n" ;
test::shared::method(2) ;
`);
$world2->unlink_world($world0) ;
$world0->eval(q`
my @incs = sort keys %INC ;
print "incs> @incs\n" ;
print ">> $test::shared::VAR\n" ;
test::shared::method('0.1') ;
`);
ok($stdout0 , "incs> strict.pm test/shared.pm\n>> foovar\nSHARED[1]! [w0][w0] <<0>>\nincs> strict.pm test/shared.pm\n>> foovar\nSHARED[4]! [w0][w0] <<0.1>>\n");
ok($stderr0 , '') ;
ok($stdout1 , "incs> strict.pm test/shared.pm >> #shared#\n>> foovar\nSHARED[2]! [w1][w1] <<1>>\n");
ok($stderr1 , '') ;
ok($stdout2 , "incs> strict.pm test/shared.pm >> #shared#\n>> foovar\nSHARED[3]! [w2][w2] <<2>>\n");
ok($stderr2 , '') ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
on_select => sub { print "SELECT " ; } ,
on_unselect => sub { print "UNSELECT " ; } ,
) ;
$world->eval(q`
print "Test1 " ;
`);
ok($stdout , "SELECT UNSELECT SELECT Test1 UNSELECT ") ;
ok($stderr , '') ;
}
#########################
{
my ( $stdout , $stderr , $headout ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
headout => \$headout ,
headspliter => 'HTML' ,
autohead => 1 ,
#flush => 1 ,
on_closeheaders => sub {
my ( $world ) = @_ ;
my $headers = $world->headers ;
my $data = $world->stdout_data ;
$headers =~ s/[\r\n\012\015]+/\n/gs ;
$headers =~ s/^[ \t]+\n/\n/gs ;
$headers =~ s/^\n+//s ;
$headers =~ s/\n+$//s ;
$headers =~ s/\n+/\015\012/gs ;
$headers .= "\015\012\015\012" ;
$world->print( "HEADERS[[\n$headers]]\n" ) ;
$world->headers('') ;
} ,
on_exit => sub {
my ( $world ) = @_ ;
$world->print("<<ON_EXIT_IN>>\n");
return 0 ;
} ,
) ;
$world->print("headers init!\n") ;
$world->eval(q`
print "Content-type: text/html\n\n" ;
print "<html>\n" ;
print "content1\n" ;
$SAFEWORLD->print_header("1: more headers after close!\n");
$|=1;
print "content2\n" ;
$SAFEWORLD->print_header("2: more headers after flush!\n");
$|=0;
print STDERR "error!\n" ;
warn("warning!!!") ;
print "content3\n" ;
exit ;
print "end!\n" ;
`);
$world->close ; ## flush all and exit.
ok($headout , "2: more headers after flush!\n") ;
$stdout =~ s/\r\n?/\n/gs ;
ok($stdout , q`HEADERS[[
headers init!
Content-type: text/html
1: more headers after close!
]]
<html>
content1
content2
content3
<<ON_EXIT_IN>>
end!
`) ;
$stderr =~ s/eval \d+/eval x/gi ;
ok($stderr , "error!\nwarning!!! at (eval x) line 19.\n") ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
) ;
ok(1);
print "## Socket test at www.perl.com: to test bug at select() with IO::Socket.\n" ;
$world->eval(q`
use IO::Socket ;
my $host = 'www.perl.com' ;
my $sel = select ;
print "SEL: $sel\n" ;
my $sock = new IO::Socket::INET(
PeerAddr => $host,
PeerPort => 80,
Proto => 'tcp',
Timeout => 30) ;
if ($sock) {
$sock->autoflush(1) ;
my $rn = "\015\012" ;
print $sock "GET / HTTP/1.0$rn" ;
print $sock "Host: $host$rn" ;
print $sock "$rn$rn" ;
my $data ;
1 while( read($sock, $data , 1024*4, length($data) ) ) ;
print "DATA: " ;
if ( $data =~ /<html>.*?<\/html>/si ) { print "ok\n" ;}
else { print "error\n" ;}
}
else { print "SOCKET ERROR!\n" ;}
close($sock) ;
`);
$world->close ;
if ( $stdout =~ /SOCKET ERROR/s ) {
print "## ** Socket test skiped! Can't connect to www.perl.com!\n" ;
}
else {
my $root = $world->root ;
print " "; ok( $stdout =~ /SEL: (?:main|$root)::STDOUT/s ) ;
print " "; ok( $stdout =~ /DATA: ok/s ) ;
print "## End of Socket tests.\n" ;
}
## Can't have warnings for constant sub redefinition! Bug at Perl-5.8.x
ok($stderr , '') ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
sub test { print "sub_test[@_]" ; }
print "A|" ;
my $out ;
$SAFEWORLD->redirect_stdout(\$out) ;
test(123);
$SAFEWORLD->restore_stdout ;
print "B|" ;
print "OUT: <$out>" ;
`);
ok($stdout , 'A|B|OUT: <sub_test[123]>') ;
ok($stderr , '') ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
&null ;
`);
$world->eval(q`
sub test { print "sub_test[@_]" ; }
print "A|" ;
&test ;
print "B|" ;
`);
ok($stdout , 'A|sub_test[]B|') ;
ok($stderr =~ /Undefined subroutine &(?:main|SAFEWORLD\d+)::null/) ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
print "A|" ;
exit ;
print "B|" ;
`);
$world->eval(q`
print "C|" ;
`);
ok($stdout , 'A|') ;
ok($stderr =~ /Can't evaluate after exit!/) ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q`
print "A|" ;
die ;
print "B|" ;
`);
$world->eval(q`
print "C|" ;
`);
ok($stdout , 'A|C|') ;
ok($stderr =~ /Died at \(eval \d+\)/) ;
}
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->eval(q` print "a> @_|" ; `);
$world->eval_args(q` print "b> @_|" ;` , 123 , 456);
ok($stdout , 'a> |b> 123 456|') ;
ok($stderr , '') ;
}
#########################
{
package foo ;
use vars qw($var);
$var = 'foovar!' ;
sub test { print "TEST! $var >> @_|" ; }
package main ;
use Safe::World::Scope ;
my $scope = new Safe::World::Scope('foo') ;
my ( $stdout , $stderr ) ;
my $world = new Safe::World(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
$world->set('$scope' , $scope , 1) ; ## Set the object inside the World.
$world->eval(q`
$scope->call('test','argmunet') ;
my $v = $scope->get('$var') ;
print "var: $v|" ;
$scope->set('$var', '123' ) ;
$v = $scope->get('$var') ;
print "var after set: $v|" ;
`);
ok($stdout , 'TEST! foovar! >> argmunet|var: foovar!|var after set: 123|') ;
ok($stderr , '') ;
}
#########################
{
my ( $stdout0 , $stderr0 ) ;
my $world_cache = Safe::World->new(
stdout => \$stdout0 ,
stderr => \$stderr0 ,
flush => 1 ,
) ;
my ( $link_pack , $inc ) = $world_cache->use_shared('test::useshared') ;
ok( @$link_pack ) ;
ok( (keys %$inc) ) ;
$world_cache->eval(q`
print test::useshared::test() . "#" ;
print test::required::test() . "#" ;
`);
my ( $stdout1 , $stderr1 ) ;
my $world = Safe::World->new(
stdout => \$stdout1 ,
stderr => \$stderr1 ,
flush => 1 ,
) ;
$world->link_world($world_cache) ;
$world->eval(q`
print test::useshared::test() . "#" ;
print test::required::test() . "#" ;
print "$INC{'test/useshared.pm'}|$INC{'test/required.pm'}" ;
`);
ok($stdout0 , 'useshared_ok#required_ok#') ;
ok($stderr0 , '') ;
ok($stdout1 , 'useshared_ok#required_ok##shared#|#shared#') ;
ok($stderr1 , '') ;
}
if (0) {
#########################
{
my ( $stdout , $stderr ) ;
my $world = Safe::World->new(
stdout => \$stdout ,
stderr => \$stderr ,
flush => 1 ,
) ;
my $outvar ;
$world->eval_args(q` $refout = $_[0] ;` , \$outvar ) ;
$world->eval(q` print "REF: ". ref($refout) ; `) ;
$world->eval(q` $$refout = 123 ;`) ;
ok($outvar , 123) ;
$world->eval(q`
require test::endblk ;
`) ;
$world->close ;
$world = undef ;
ok($outvar , 'END BLOCK EXECUTED!') ;
ok($stdout , 'REF: SCALAR') ;
ok($stderr , '') ;
}
#########################
}
print "\nThe End! By!\n" ;
1 ;