[perl5.git] / t / op / inccode.t

#!./perl -w

# Tests for the coderef-in-@INC feature

BEGIN {
    chdir 't' if -d 't';
    @INC = qw(. ../lib);
    require './test.pl';
}

use Config;

my $can_fork   = 0;
my $has_perlio = $Config{useperlio};

unless (is_miniperl()) {
    if ($Config{d_fork} && eval 'require POSIX; 1') {
	$can_fork = 1;
    }
}

use strict;

plan(tests => 49 + !is_miniperl() * (3 + 14 * $can_fork));

sub get_temp_fh {
    my $f = tempfile();
    open my $fh, ">$f" or die "Can't create $f: $!";
    print $fh "package ".substr($_[0],0,-3).";\n1;\n";
    print $fh $_[1] if @_ > 1;
    close $fh or die "Couldn't close: $!";
    open $fh, $f or die "Can't open $f: $!";
    return $fh;
}

sub fooinc {
    my ($self, $filename) = @_;
    if (substr($filename,0,3) eq 'Foo') {
	return get_temp_fh($filename);
    }
    else {
        return undef;
    }
}

push @INC, \&fooinc;

my $evalret = eval { require Bar; 1 };
ok( !$evalret,      'Trying non-magic package' );

$evalret = eval { require Foo; 1 };
die $@ if $@;
ok( $evalret,                      'require Foo; magic via code ref'  );
ok( exists $INC{'Foo.pm'},         '  %INC sees Foo.pm' );
is( ref $INC{'Foo.pm'}, 'CODE',    '  val Foo.pm is a coderef in %INC' );
is( $INC{'Foo.pm'}, \&fooinc,	   '  val Foo.pm is correct in %INC' );

$evalret = eval "use Foo1; 1;";
die $@ if $@;
ok( $evalret,                      'use Foo1' );
ok( exists $INC{'Foo1.pm'},        '  %INC sees Foo1.pm' );
is( ref $INC{'Foo1.pm'}, 'CODE',   '  val Foo1.pm is a coderef in %INC' );
is( $INC{'Foo1.pm'}, \&fooinc,     '  val Foo1.pm is correct in %INC' );

$evalret = eval { do 'Foo2.pl'; 1 };
die $@ if $@;
ok( $evalret,                      'do "Foo2.pl"' );
ok( exists $INC{'Foo2.pl'},        '  %INC sees Foo2.pl' );
is( ref $INC{'Foo2.pl'}, 'CODE',   '  val Foo2.pl is a coderef in %INC' );
is( $INC{'Foo2.pl'}, \&fooinc,     '  val Foo2.pl is correct in %INC' );

pop @INC;


sub fooinc2 {
    my ($self, $filename) = @_;
    if (substr($filename, 0, length($self->[1])) eq $self->[1]) {
	return get_temp_fh($filename);
    }
    else {
        return undef;
    }
}

my $arrayref = [ \&fooinc2, 'Bar' ];
push @INC, $arrayref;

$evalret = eval { require Foo; 1; };
die $@ if $@;
ok( $evalret,                     'Originally loaded packages preserved' );
$evalret = eval { require Foo3; 1; };
ok( !$evalret,                    'Original magic INC purged' );

$evalret = eval { require Bar; 1 };
die $@ if $@;
ok( $evalret,                     'require Bar; magic via array ref' );
ok( exists $INC{'Bar.pm'},        '  %INC sees Bar.pm' );
is( ref $INC{'Bar.pm'}, 'ARRAY',  '  val Bar.pm is an arrayref in %INC' );
is( $INC{'Bar.pm'}, $arrayref,    '  val Bar.pm is correct in %INC' );

ok( eval "use Bar1; 1;",          'use Bar1' );
ok( exists $INC{'Bar1.pm'},       '  %INC sees Bar1.pm' );
is( ref $INC{'Bar1.pm'}, 'ARRAY', '  val Bar1.pm is an arrayref in %INC' );
is( $INC{'Bar1.pm'}, $arrayref,   '  val Bar1.pm is correct in %INC' );

ok( eval { do 'Bar2.pl'; 1 },     'do "Bar2.pl"' );
ok( exists $INC{'Bar2.pl'},       '  %INC sees Bar2.pl' );
is( ref $INC{'Bar2.pl'}, 'ARRAY', '  val Bar2.pl is an arrayref in %INC' );
is( $INC{'Bar2.pl'}, $arrayref,   '  val Bar2.pl is correct in %INC' );

pop @INC;

sub FooLoader::INC {
    my ($self, $filename) = @_;
    if (substr($filename,0,4) eq 'Quux') {
	return get_temp_fh($filename);
    }
    else {
        return undef;
    }
}

my $href = bless( {}, 'FooLoader' );
push @INC, $href;

$evalret = eval { require Quux; 1 };
die $@ if $@;
ok( $evalret,                      'require Quux; magic via hash object' );
ok( exists $INC{'Quux.pm'},        '  %INC sees Quux.pm' );
is( ref $INC{'Quux.pm'}, 'FooLoader',
				   '  val Quux.pm is an object in %INC' );
is( $INC{'Quux.pm'}, $href,        '  val Quux.pm is correct in %INC' );

pop @INC;

my $aref = bless( [], 'FooLoader' );
push @INC, $aref;

$evalret = eval { require Quux1; 1 };
die $@ if $@;
ok( $evalret,                      'require Quux1; magic via array object' );
ok( exists $INC{'Quux1.pm'},       '  %INC sees Quux1.pm' );
is( ref $INC{'Quux1.pm'}, 'FooLoader',
				   '  val Quux1.pm is an object in %INC' );
is( $INC{'Quux1.pm'}, $aref,       '  val Quux1.pm  is correct in %INC' );

pop @INC;

my $sref = bless( \(my $x = 1), 'FooLoader' );
push @INC, $sref;

$evalret = eval { require Quux2; 1 };
die $@ if $@;
ok( $evalret,                      'require Quux2; magic via scalar object' );
ok( exists $INC{'Quux2.pm'},       '  %INC sees Quux2.pm' );
is( ref $INC{'Quux2.pm'}, 'FooLoader',
				   '  val Quux2.pm is an object in %INC' );
is( $INC{'Quux2.pm'}, $sref,       '  val Quux2.pm is correct in %INC' );

pop @INC;

push @INC, sub {
    my ($self, $filename) = @_;
    if (substr($filename,0,4) eq 'Toto') {
	$INC{$filename} = 'xyz';
	return get_temp_fh($filename);
    }
    else {
        return undef;
    }
};

$evalret = eval { require Toto; 1 };
die $@ if $@;
ok( $evalret,                      'require Toto; magic via anonymous code ref'  );
ok( exists $INC{'Toto.pm'},        '  %INC sees Toto.pm' );
ok( ! ref $INC{'Toto.pm'},         q/  val Toto.pm isn't a ref in %INC/ );
is( $INC{'Toto.pm'}, 'xyz',	   '  val Toto.pm is correct in %INC' );

pop @INC;

push @INC, sub {
    my ($self, $filename) = @_;
    if ($filename eq 'abc.pl') {
	return get_temp_fh($filename, qq(return "abc";\n));
    }
    else {
	return undef;
    }
};

my $ret = "";
$ret ||= do 'abc.pl';
is( $ret, 'abc', 'do "abc.pl" sees return value' );

{
    my $filename = './Foo.pm';
    #local @INC; # local fails on tied @INC
    my @old_INC = @INC; # because local doesn't work on tied arrays
    @INC = sub { $filename = 'seen'; return undef; };
    eval { require $filename; };
    is( $filename, 'seen', 'the coderef sees fully-qualified pathnames' );
    @INC = @old_INC;
}

# this will segfault if it fails

sub PVBM () { 'foo' }
{ my $dummy = index 'foo', PVBM }

# I don't know whether these requires should succeed or fail. 5.8 failed
# all of them; 5.10 with an ordinary constant in place of PVBM lets the
# latter two succeed. For now I don't care, as long as they don't
# segfault :).

unshift @INC, sub { PVBM };
eval 'require foo';
ok( 1, 'returning PVBM doesn\'t segfault require' );
eval 'use foo';
ok( 1, 'returning PVBM doesn\'t segfault use' );
shift @INC;
unshift @INC, sub { \PVBM };
eval 'require foo';
ok( 1, 'returning PVBM ref doesn\'t segfault require' );
eval 'use foo';
ok( 1, 'returning PVBM ref doesn\'t segfault use' );
shift @INC;

exit if is_miniperl();

SKIP: {
    skip( "No PerlIO available", 3 ) unless $has_perlio;
    pop @INC;

    push @INC, sub {
        my ($cr, $filename) = @_;
        my $module = $filename; $module =~ s,/,::,g; $module =~ s/\.pm$//;
        open my $fh, '<',
             \"package $module; sub complain { warn q() }; \$::file = __FILE__;"
	    or die $!;
        $INC{$filename} = "/custom/path/to/$filename";
        return $fh;
    };

    require Publius::Vergilius::Maro;
    is( $INC{'Publius/Vergilius/Maro.pm'},
        '/custom/path/to/Publius/Vergilius/Maro.pm', '%INC set correctly');
    is( our $file, '/custom/path/to/Publius/Vergilius/Maro.pm',
        '__FILE__ set correctly' );
    {
        my $warning;
        local $SIG{__WARN__} = sub { $warning = shift };
        Publius::Vergilius::Maro::complain();
        like( $warning, qr{something's wrong at /custom/path/to/Publius/Vergilius/Maro.pm}, 'warn() reports correct file source' );
    }
}
pop @INC;

if ($can_fork) {
    require PerlIO::scalar;
    # This little bundle of joy generates n more recursive use statements,
    # with each module chaining the next one down to 0. If it works, then we
    # can safely nest subprocesses
    my $use_filter_too;
    push @INC, sub {
	return unless $_[1] =~ /^BBBLPLAST(\d+)\.pm/;
	my $pid = open my $fh, "-|";
	if ($pid) {
	    # Parent
	    return $fh unless $use_filter_too;
	    # Try filters and state in addition.
	    return ($fh, sub {s/$_[1]/pass/; return}, "die")
	}
	die "Can't fork self: $!" unless defined $pid;

	# Child
	my $count = $1;
	# Lets force some fun with odd sized reads.
	$| = 1;
	print 'push @main::bbblplast, ';
	print "$count;\n";
	if ($count--) {
	    print "use BBBLPLAST$count;\n";
	}
	if ($use_filter_too) {
	    print "die('In $_[1]');";
	} else {
	    print "pass('In $_[1]');";
	}
	print '"Truth"';
	POSIX::_exit(0);
	die "Can't get here: $!";
    };

    @::bbblplast = ();
    require BBBLPLAST5;
    is ("@::bbblplast", "0 1 2 3 4 5", "All ran");

    foreach (keys %INC) {
	delete $INC{$_} if /^BBBLPLAST/;
    }

    @::bbblplast = ();
    $use_filter_too = 1;

    require BBBLPLAST5;

    is ("@::bbblplast", "0 1 2 3 4 5", "All ran with a filter");
}
Commit	Line	Data
69026470	1	#!./perl -w
e5d18500 AMS	2
	3	# Tests for the coderef-in-@INC feature
	4
	5	BEGIN {
f8973f08	6	chdir 't' if -d 't';
69026470	7	@INC = qw(. ../lib);
9c123506	8	require './test.pl';
e5d18500	9	}
ab742322	10
9c123506 NC	11	use Config;
	12
	13	my $can_fork = 0;
	14	my $has_perlio = $Config{useperlio};
	15
	16	unless (is_miniperl()) {
240b6766	17	if ($Config{d_fork} && eval 'require POSIX; 1') {
6b75eab3 NC	18	$can_fork = 1;
	19	}
	20	}
f8973f08	21
6b75eab3	22	use strict;
69026470	23
9c123506	24	plan(tests => 49 + !is_miniperl() * (3 + 14 * $can_fork));
47de4e93 RGS	25
47de4e93 RGS	26	sub get_temp_fh {
1c25d394	27	my $f = tempfile();
22e2837f	28	open my $fh, ">$f" or die "Can't create $f: $!";
3a5db825 GA	29	print $fh "package ".substr($_[0],0,-3).";\n1;\n";
3a5db825 GA	30	print $fh $_[1] if @_ > 1;
d1e4d418	31	close $fh or die "Couldn't close: $!";
47de4e93 RGS	32	open $fh, $f or die "Can't open $f: $!";
	33	return $fh;
	34	}
f8973f08	35
e5d18500 AMS	36	sub fooinc {
	37	my ($self, $filename) = @_;
	38	if (substr($filename,0,3) eq 'Foo') {
47de4e93	39	return get_temp_fh($filename);
e5d18500 AMS	40	}
e5d18500 AMS	41	else {
f8973f08	42	return undef;
e5d18500 AMS	43	}
	44	}
	45
	46	push @INC, \&fooinc;
	47
d1e4d418 A	48	my $evalret = eval { require Bar; 1 };
	49	ok( !$evalret, 'Trying non-magic package' );
	50
	51	$evalret = eval { require Foo; 1 };
	52	die $@ if $@;
	53	ok( $evalret, 'require Foo; magic via code ref' );
	54	ok( exists $INC{'Foo.pm'}, ' %INC sees Foo.pm' );
	55	is( ref $INC{'Foo.pm'}, 'CODE', ' val Foo.pm is a coderef in %INC' );
	56	is( $INC{'Foo.pm'}, \&fooinc, ' val Foo.pm is correct in %INC' );
	57
	58	$evalret = eval "use Foo1; 1;";
	59	die $@ if $@;
	60	ok( $evalret, 'use Foo1' );
	61	ok( exists $INC{'Foo1.pm'}, ' %INC sees Foo1.pm' );
	62	is( ref $INC{'Foo1.pm'}, 'CODE', ' val Foo1.pm is a coderef in %INC' );
	63	is( $INC{'Foo1.pm'}, \&fooinc, ' val Foo1.pm is correct in %INC' );
	64
	65	$evalret = eval { do 'Foo2.pl'; 1 };
	66	die $@ if $@;
	67	ok( $evalret, 'do "Foo2.pl"' );
	68	ok( exists $INC{'Foo2.pl'}, ' %INC sees Foo2.pl' );
	69	is( ref $INC{'Foo2.pl'}, 'CODE', ' val Foo2.pl is a coderef in %INC' );
	70	is( $INC{'Foo2.pl'}, \&fooinc, ' val Foo2.pl is correct in %INC' );
e5d18500 AMS	71
	72	pop @INC;
	73
f8973f08	74
e5d18500 AMS	75	sub fooinc2 {
	76	my ($self, $filename) = @_;
	77	if (substr($filename, 0, length($self->[1])) eq $self->[1]) {
47de4e93	78	return get_temp_fh($filename);
e5d18500 AMS	79	}
e5d18500 AMS	80	else {
f8973f08	81	return undef;
e5d18500 AMS	82	}
	83	}
	84
47de4e93 RGS	85	my $arrayref = [ \&fooinc2, 'Bar' ];
47de4e93 RGS	86	push @INC, $arrayref;
e5d18500	87
d1e4d418 A	88	$evalret = eval { require Foo; 1; };
	89	die $@ if $@;
	90	ok( $evalret, 'Originally loaded packages preserved' );
	91	$evalret = eval { require Foo3; 1; };
	92	ok( !$evalret, 'Original magic INC purged' );
	93
	94	$evalret = eval { require Bar; 1 };
	95	die $@ if $@;
	96	ok( $evalret, 'require Bar; magic via array ref' );
	97	ok( exists $INC{'Bar.pm'}, ' %INC sees Bar.pm' );
	98	is( ref $INC{'Bar.pm'}, 'ARRAY', ' val Bar.pm is an arrayref in %INC' );
	99	is( $INC{'Bar.pm'}, $arrayref, ' val Bar.pm is correct in %INC' );
	100
	101	ok( eval "use Bar1; 1;", 'use Bar1' );
	102	ok( exists $INC{'Bar1.pm'}, ' %INC sees Bar1.pm' );
	103	is( ref $INC{'Bar1.pm'}, 'ARRAY', ' val Bar1.pm is an arrayref in %INC' );
	104	is( $INC{'Bar1.pm'}, $arrayref, ' val Bar1.pm is correct in %INC' );
	105
	106	ok( eval { do 'Bar2.pl'; 1 }, 'do "Bar2.pl"' );
	107	ok( exists $INC{'Bar2.pl'}, ' %INC sees Bar2.pl' );
	108	is( ref $INC{'Bar2.pl'}, 'ARRAY', ' val Bar2.pl is an arrayref in %INC' );
	109	is( $INC{'Bar2.pl'}, $arrayref, ' val Bar2.pl is correct in %INC' );
e5d18500 AMS	110
	111	pop @INC;
	112
	113	sub FooLoader::INC {
	114	my ($self, $filename) = @_;
	115	if (substr($filename,0,4) eq 'Quux') {
47de4e93	116	return get_temp_fh($filename);
e5d18500 AMS	117	}
e5d18500 AMS	118	else {
f8973f08	119	return undef;
e5d18500 AMS	120	}
	121	}
	122
47de4e93 RGS	123	my $href = bless( {}, 'FooLoader' );
47de4e93 RGS	124	push @INC, $href;
e5d18500	125
d1e4d418 A	126	$evalret = eval { require Quux; 1 };
	127	die $@ if $@;
	128	ok( $evalret, 'require Quux; magic via hash object' );
	129	ok( exists $INC{'Quux.pm'}, ' %INC sees Quux.pm' );
6ece0f6b	130	is( ref $INC{'Quux.pm'}, 'FooLoader',
d1e4d418 A	131	' val Quux.pm is an object in %INC' );
d1e4d418 A	132	is( $INC{'Quux.pm'}, $href, ' val Quux.pm is correct in %INC' );
e5d18500 AMS	133
	134	pop @INC;
	135
47de4e93 RGS	136	my $aref = bless( [], 'FooLoader' );
47de4e93 RGS	137	push @INC, $aref;
e5d18500	138
d1e4d418 A	139	$evalret = eval { require Quux1; 1 };
	140	die $@ if $@;
	141	ok( $evalret, 'require Quux1; magic via array object' );
	142	ok( exists $INC{'Quux1.pm'}, ' %INC sees Quux1.pm' );
6ece0f6b	143	is( ref $INC{'Quux1.pm'}, 'FooLoader',
d1e4d418 A	144	' val Quux1.pm is an object in %INC' );
d1e4d418 A	145	is( $INC{'Quux1.pm'}, $aref, ' val Quux1.pm is correct in %INC' );
e5d18500 AMS	146
	147	pop @INC;
	148
47de4e93 RGS	149	my $sref = bless( \(my $x = 1), 'FooLoader' );
47de4e93 RGS	150	push @INC, $sref;
e5d18500	151
d1e4d418 A	152	$evalret = eval { require Quux2; 1 };
	153	die $@ if $@;
	154	ok( $evalret, 'require Quux2; magic via scalar object' );
	155	ok( exists $INC{'Quux2.pm'}, ' %INC sees Quux2.pm' );
6ece0f6b	156	is( ref $INC{'Quux2.pm'}, 'FooLoader',
d1e4d418 A	157	' val Quux2.pm is an object in %INC' );
d1e4d418 A	158	is( $INC{'Quux2.pm'}, $sref, ' val Quux2.pm is correct in %INC' );
f8973f08 MS	159
f8973f08 MS	160	pop @INC;
9ae8cd5b RGS	161
	162	push @INC, sub {
	163	my ($self, $filename) = @_;
	164	if (substr($filename,0,4) eq 'Toto') {
	165	$INC{$filename} = 'xyz';
	166	return get_temp_fh($filename);
	167	}
	168	else {
	169	return undef;
	170	}
	171	};
	172
d1e4d418 A	173	$evalret = eval { require Toto; 1 };
	174	die $@ if $@;
	175	ok( $evalret, 'require Toto; magic via anonymous code ref' );
	176	ok( exists $INC{'Toto.pm'}, ' %INC sees Toto.pm' );
	177	ok( ! ref $INC{'Toto.pm'}, q/ val Toto.pm isn't a ref in %INC/ );
	178	is( $INC{'Toto.pm'}, 'xyz', ' val Toto.pm is correct in %INC' );
9ae8cd5b RGS	179
9ae8cd5b RGS	180	pop @INC;
d820be44	181
3a5db825 GA	182	push @INC, sub {
	183	my ($self, $filename) = @_;
	184	if ($filename eq 'abc.pl') {
	185	return get_temp_fh($filename, qq(return "abc";\n));
	186	}
	187	else {
	188	return undef;
	189	}
	190	};
	191
6b75eab3	192	my $ret = "";
3a5db825 GA	193	$ret \|\|= do 'abc.pl';
	194	is( $ret, 'abc', 'do "abc.pl" sees return value' );
	195
ab742322	196	{
7b903762	197	my $filename = './Foo.pm';
c38a6530 RD	198	#local @INC; # local fails on tied @INC
c38a6530 RD	199	my @old_INC = @INC; # because local doesn't work on tied arrays
ab742322 RB	200	@INC = sub { $filename = 'seen'; return undef; };
	201	eval { require $filename; };
	202	is( $filename, 'seen', 'the coderef sees fully-qualified pathnames' );
c38a6530	203	@INC = @old_INC;
ab742322 RB	204	}
ab742322 RB	205
6e592b3a BM	206	# this will segfault if it fails
	207
	208	sub PVBM () { 'foo' }
	209	{ my $dummy = index 'foo', PVBM }
	210
	211	# I don't know whether these requires should succeed or fail. 5.8 failed
	212	# all of them; 5.10 with an ordinary constant in place of PVBM lets the
	213	# latter two succeed. For now I don't care, as long as they don't
	214	# segfault :).
	215
	216	unshift @INC, sub { PVBM };
	217	eval 'require foo';
	218	ok( 1, 'returning PVBM doesn\'t segfault require' );
	219	eval 'use foo';
	220	ok( 1, 'returning PVBM doesn\'t segfault use' );
	221	shift @INC;
	222	unshift @INC, sub { \PVBM };
	223	eval 'require foo';
	224	ok( 1, 'returning PVBM ref doesn\'t segfault require' );
	225	eval 'use foo';
	226	ok( 1, 'returning PVBM ref doesn\'t segfault use' );
	227	shift @INC;
	228
9c123506	229	exit if is_miniperl();
ab742322	230
240b6766 AT	231	SKIP: {
	232	skip( "No PerlIO available", 3 ) unless $has_perlio;
	233	pop @INC;
	234
	235	push @INC, sub {
	236	my ($cr, $filename) = @_;
	237	my $module = $filename; $module =~ s,/,::,g; $module =~ s/\.pm$//;
	238	open my $fh, '<',
	239	\"package $module; sub complain { warn q() }; \$::file = __FILE__;"
	240	or die $!;
	241	$INC{$filename} = "/custom/path/to/$filename";
	242	return $fh;
	243	};
	244
	245	require Publius::Vergilius::Maro;
	246	is( $INC{'Publius/Vergilius/Maro.pm'},
	247	'/custom/path/to/Publius/Vergilius/Maro.pm', '%INC set correctly');
	248	is( our $file, '/custom/path/to/Publius/Vergilius/Maro.pm',
	249	'__FILE__ set correctly' );
	250	{
	251	my $warning;
	252	local $SIG{__WARN__} = sub { $warning = shift };
	253	Publius::Vergilius::Maro::complain();
	254	like( $warning, qr{something's wrong at /custom/path/to/Publius/Vergilius/Maro.pm}, 'warn() reports correct file source' );
	255	}
a3b58a99	256	}
a3b58a99 RGS	257	pop @INC;
a3b58a99 RGS	258
6b75eab3 NC	259	if ($can_fork) {
	260	require PerlIO::scalar;
	261	# This little bundle of joy generates n more recursive use statements,
	262	# with each module chaining the next one down to 0. If it works, then we
	263	# can safely nest subprocesses
	264	my $use_filter_too;
	265	push @INC, sub {
	266	return unless $_[1] =~ /^BBBLPLAST(\d+)\.pm/;
	267	my $pid = open my $fh, "-\|";
	268	if ($pid) {
	269	# Parent
	270	return $fh unless $use_filter_too;
	271	# Try filters and state in addition.
	272	return ($fh, sub {s/$_[1]/pass/; return}, "die")
	273	}
	274	die "Can't fork self: $!" unless defined $pid;
	275
	276	# Child
	277	my $count = $1;
	278	# Lets force some fun with odd sized reads.
	279	$\| = 1;
	280	print 'push @main::bbblplast, ';
	281	print "$count;\n";
	282	if ($count--) {
	283	print "use BBBLPLAST$count;\n";
	284	}
	285	if ($use_filter_too) {
	286	print "die('In $_[1]');";
	287	} else {
	288	print "pass('In $_[1]');";
	289	}
	290	print '"Truth"';
	291	POSIX::_exit(0);
	292	die "Can't get here: $!";
	293	};
	294
	295	@::bbblplast = ();
	296	require BBBLPLAST5;
	297	is ("@::bbblplast", "0 1 2 3 4 5", "All ran");
	298
	299	foreach (keys %INC) {
	300	delete $INC{$_} if /^BBBLPLAST/;
	301	}
	302
	303	@::bbblplast = ();
	304	$use_filter_too = 1;
	305
	306	require BBBLPLAST5;
	307
	308	is ("@::bbblplast", "0 1 2 3 4 5", "All ran with a filter");
	309	}