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

#!./perl
#
# check UNIVERSAL
#

BEGIN {
    chdir 't' if -d 't';
    @INC = '../lib';
    $| = 1;
    require "./test.pl";
}

plan tests => 143;

$a = {};
bless $a, "Bob";
ok $a->isa("Bob");

package Human;
sub eat {}

package Female;
@ISA=qw(Human);

package Alice;
@ISA=qw(Bob Female);
sub sing;
sub drink { return "drinking " . $_[1]  }
sub new { bless {} }

$Alice::VERSION = 2.718;

{
    package Cedric;
    our @ISA;
    use base qw(Human);
}

{
    package Programmer;
    our $VERSION = 1.667;

    sub write_perl { 1 }
}

package main;


$a = new Alice;

ok $a->isa("Alice");
ok $a->isa("main::Alice");    # check that alternate class names work

ok(("main::Alice"->new)->isa("Alice"));

ok $a->isa("Bob");
ok $a->isa("main::Bob");

ok $a->isa("Female");

ok ! $a->isa("Female\0NOT REALLY!"), "->isa is nul-clean.";

ok $a->isa("Human");

ok ! $a->isa("Male");

ok ! $a->isa('Programmer');

ok $a->isa("HASH");

ok $a->can("eat");
ok ! $a->can("eat\0Except not!"), "->can is nul-clean.";
ok ! $a->can("sleep");
ok my $ref = $a->can("drink");        # returns a coderef
is $a->$ref("tea"), "drinking tea"; # ... which works
ok $ref = $a->can("sing");
eval { $a->$ref() };
ok $@;                                # ... but not if no actual subroutine

ok (!Cedric->isa('Programmer'));

ok (Cedric->isa('Human'));

push(@Cedric::ISA,'Programmer');

ok (Cedric->isa('Programmer'));

{
    package Alice;
    base::->import('Programmer');
}

ok $a->isa('Programmer');
ok $a->isa("Female");

@Cedric::ISA = qw(Bob);

ok (!Cedric->isa('Programmer'));

my $b = 'abc';
my @refs = qw(SCALAR SCALAR     LVALUE      GLOB ARRAY HASH CODE);
my @vals = (  \$b,   \3.14, \substr($b,1,1), \*b,  [],  {}, sub {} );
for ($p=0; $p < @refs; $p++) {
    for ($q=0; $q < @vals; $q++) {
        is UNIVERSAL::isa($vals[$p], $refs[$q]), ($p==$q or $p+$q==1);
    };
};

ok UNIVERSAL::can(23, "can");
++${"23::foo"};
ok UNIVERSAL::can("23", "can"), '"23" can can when the pack exists';
ok UNIVERSAL::can(23, "can"), '23 can can when the pack exists';
sub IO::Handle::turn {}
ok UNIVERSAL::can(*STDOUT, 'turn'), 'globs with IOs can';
ok UNIVERSAL::can(\*STDOUT, 'turn'), 'globrefs with IOs can';
ok UNIVERSAL::can("STDOUT", 'turn'), 'IO barewords can';

ok $a->can("VERSION");

ok $a->can("can");
ok ! $a->can("export_tags");	# a method in Exporter

cmp_ok eval { $a->VERSION }, '==', 2.718;

ok ! (eval { $a->VERSION(2.719) });
like $@, qr/^Alice version 2.719 required--this is only version 2.718 at /;

ok (eval { $a->VERSION(2.718) });
is $@, '';

ok ! (eval { $a->VERSION("version") });
like $@, qr/^Invalid version format/;

$aversion::VERSION = "version";
ok ! (eval { aversion->VERSION(2.719) });
like $@, qr/^Invalid version format/;

my $subs = join ' ', sort grep { defined &{"UNIVERSAL::$_"} } keys %UNIVERSAL::;
if ('a' lt 'A') {
    is $subs, "can isa DOES VERSION";
} else {
    is $subs, "DOES VERSION can isa";
}

ok $a->isa("UNIVERSAL");

ok ! UNIVERSAL::isa([], "UNIVERSAL");

ok ! UNIVERSAL::can({}, "can");

ok UNIVERSAL::isa(Alice => "UNIVERSAL");

cmp_ok UNIVERSAL::can(Alice => "can"), '==', \&UNIVERSAL::can;

# now use UNIVERSAL.pm and see what changes
eval "use UNIVERSAL";

ok $a->isa("UNIVERSAL");

my $sub2 = join ' ', sort grep { defined &{"UNIVERSAL::$_"} } keys %UNIVERSAL::;
# XXX import being here is really a bug
if ('a' lt 'A') {
    is $sub2, "can import isa DOES VERSION";
} else {
    is $sub2, "DOES VERSION can import isa";
}

eval 'sub UNIVERSAL::sleep {}';
ok $a->can("sleep");

ok UNIVERSAL::can($b, "can");

ok ! $a->can("export_tags");	# a method in Exporter

ok ! UNIVERSAL::isa("\xff\xff\xff\0", 'HASH');

{
    # test isa() and can() on magic variables
    "Human" =~ /(.*)/;
    ok $1->isa("Human");
    ok $1->can("eat");
    package HumanTie;
    sub TIESCALAR { bless {} }
    sub FETCH { "Human" }
    tie my($x), "HumanTie";
    ::ok $x->isa("Human");
    ::ok $x->can("eat");
}

# bugid 3284
# a second call to isa('UNIVERSAL') when @ISA is null failed due to caching

@X::ISA=();
my $x = {}; bless $x, 'X';
ok $x->isa('UNIVERSAL');
ok $x->isa('UNIVERSAL');


# Check that the "historical accident" of UNIVERSAL having an import()
# method doesn't effect anyone else.
eval { Some::Package->import("bar") };
is $@, '';


# This segfaulted in a blead.
fresh_perl_is('package Foo; Foo->VERSION;  print "ok"', 'ok');

# So did this.
fresh_perl_is('$:; UNIVERSAL::isa(":","Unicode::String");print "ok"','ok');

package Foo;

sub DOES { 1 }

package Bar;

@Bar::ISA = 'Foo';

package Baz;

package main;
ok( Foo->DOES( 'bar' ), 'DOES() should call DOES() on class' );
ok( Bar->DOES( 'Bar' ), '... and should fall back to isa()' );
ok( Bar->DOES( 'Foo' ), '... even when inherited' );
ok( Baz->DOES( 'Baz' ), '... even without inheriting any other DOES()' );
ok( ! Baz->DOES( 'Foo' ), '... returning true or false appropriately' );

ok( ! "T"->DOES( "T\0" ), 'DOES() is nul-clean' );
ok( ! Baz->DOES( "Baz\0Boy howdy" ), 'DOES() is nul-clean' );

package Pig;
package Bodine;
Bodine->isa('Pig');
*isa = \&UNIVERSAL::isa;
eval { isa({}, 'HASH') };
::is($@, '', "*isa correctly found");

package main;
eval { UNIVERSAL::DOES([], "foo") };
like( $@, qr/Can't call method "DOES" on unblessed reference/,
    'DOES call error message says DOES, not isa' );

# Tests for can seem to be split between here and method.t
# Add the verbatim perl code mentioned in the comments of
# http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2001-05/msg01710.html
# but never actually tested.
is(UNIVERSAL->can("NoSuchPackage::foo"), undef);

@splatt::ISA = 'zlopp';
ok (splatt->isa('zlopp'));
ok (!splatt->isa('plop'));

# This should reset the ->isa lookup cache
@splatt::ISA = 'plop';
# And here is the new truth.
ok (!splatt->isa('zlopp'));
ok (splatt->isa('plop'));

use warnings "deprecated";
{
    my $m;
    local $SIG{__WARN__} = sub { $m = $_[0] };
    eval "use UNIVERSAL 'can'";
    like($@, qr/^UNIVERSAL does not export anything\b/,
	"error for UNIVERSAL->import('can')");
    is($m, undef,
	"no deprecation warning for UNIVERSAL->import('can')");

	  undef $m;
    eval "use UNIVERSAL";
    is($@, "",
	"no error for UNIVERSAL->import");
    is($m, undef,
	"no deprecation warning for UNIVERSAL->import");
}

# Test: [perl #66112]: change @ISA inside  sub isa
{
    package RT66112::A;

    package RT66112::B;

    sub isa {
	my $self = shift;
	@ISA = qw/RT66112::A/;
	return $self->SUPER::isa(@_);
    }

    package RT66112::C;

    package RT66112::D;

    sub isa {
	my $self = shift;
	@RT66112::E::ISA = qw/RT66112::A/;
	return $self->SUPER::isa(@_);
    }

    package RT66112::E;

    package main;

    @RT66112::B::ISA = qw//;
    @RT66112::C::ISA = qw/RT66112::B/;
    @RT66112::T1::ISA = qw/RT66112::C/;
    ok(RT66112::T1->isa('RT66112::C'), "modify \@ISA in isa (RT66112::T1 isa RT66112::C)");

    @RT66112::B::ISA = qw//;
    @RT66112::C::ISA = qw/RT66112::B/;
    @RT66112::T2::ISA = qw/RT66112::C/;
    ok(RT66112::T2->isa('RT66112::B'), "modify \@ISA in isa (RT66112::T2 isa RT66112::B)");

    @RT66112::B::ISA = qw//;
    @RT66112::C::ISA = qw/RT66112::B/;
    @RT66112::T3::ISA = qw/RT66112::C/;
    ok(RT66112::T3->isa('RT66112::A'), "modify \@ISA in isa (RT66112::T3 isa RT66112::A)") or require mro, diag "@{mro::get_linear_isa('RT66112::T3')}";

    @RT66112::E::ISA = qw/RT66112::D/;
    @RT66112::T4::ISA = qw/RT66112::E/;
    ok(RT66112::T4->isa('RT66112::E'), "modify \@ISA in isa (RT66112::T4 isa RT66112::E)");

    @RT66112::E::ISA = qw/RT66112::D/;
    @RT66112::T5::ISA = qw/RT66112::E/;
    ok(! RT66112::T5->isa('RT66112::D'), "modify \@ISA in isa (RT66112::T5 not isa RT66112::D)");

    @RT66112::E::ISA = qw/RT66112::D/;
    @RT66112::T6::ISA = qw/RT66112::E/;
    ok(RT66112::T6->isa('RT66112::A'), "modify \@ISA in isa (RT66112::T6 isa RT66112::A)");
}

ok(Undeclared->can("can"));
sub Undeclared::foo { }
ok(Undeclared->can("foo"));
ok(!Undeclared->can("something_else"));

ok(Undeclared->isa("UNIVERSAL"));

# keep this at the end to avoid messing up earlier tests, since it modifies
# @UNIVERSAL::ISA
@UNIVERSAL::ISA = ('UniversalParent');
{ package UniversalIsaTest1; }
ok(UniversalIsaTest1->isa('UniversalParent'));
ok(UniversalIsaTest2->isa('UniversalParent'));
Commit	Line	Data
44a8e56a	1	#!./perl
	2	#
	3	# check UNIVERSAL
	4	#
	5
e09f3e01 MG	6	BEGIN {
e09f3e01 MG	7	chdir 't' if -d 't';
20822f61	8	@INC = '../lib';
46e4b22b	9	$\| = 1;
3e44d7c6	10	require "./test.pl";
e09f3e01 MG	11	}
e09f3e01 MG	12
1178d2cf	13	plan tests => 143;
44a8e56a	14
	15	$a = {};
	16	bless $a, "Bob";
3e44d7c6	17	ok $a->isa("Bob");
44a8e56a	18
ff0cee69	19	package Human;
ff0cee69	20	sub eat {}
44a8e56a	21
ff0cee69	22	package Female;
ff0cee69	23	@ISA=qw(Human);
44a8e56a	24
ff0cee69	25	package Alice;
ff0cee69	26	@ISA=qw(Bob Female);
39d11b7f TB	27	sub sing;
39d11b7f TB	28	sub drink { return "drinking " . $_[1] }
ff0cee69	29	sub new { bless {} }
44a8e56a	30
e09f3e01 MG	31	$Alice::VERSION = 2.718;
e09f3e01 MG	32
46e4b22b GS	33	{
	34	package Cedric;
	35	our @ISA;
	36	use base qw(Human);
	37	}
	38
	39	{
	40	package Programmer;
	41	our $VERSION = 1.667;
	42
	43	sub write_perl { 1 }
	44	}
	45
44a8e56a	46	package main;
e09f3e01	47
3e44d7c6	48
e09f3e01	49
ff0cee69	50	$a = new Alice;
44a8e56a	51
3e44d7c6 MS	52	ok $a->isa("Alice");
3e44d7c6 MS	53	ok $a->isa("main::Alice"); # check that alternate class names work
44a8e56a	54
3e44d7c6	55	ok(("main::Alice"->new)->isa("Alice"));
178d71da	56
3e44d7c6 MS	57	ok $a->isa("Bob");
3e44d7c6 MS	58	ok $a->isa("main::Bob");
e09f3e01	59
3e44d7c6	60	ok $a->isa("Female");
e09f3e01	61
072cb3f5 BF	62	ok ! $a->isa("Female\0NOT REALLY!"), "->isa is nul-clean.";
072cb3f5 BF	63
3e44d7c6	64	ok $a->isa("Human");
e09f3e01	65
3e44d7c6	66	ok ! $a->isa("Male");
e09f3e01	67
3e44d7c6	68	ok ! $a->isa('Programmer');
46e4b22b	69
3e44d7c6	70	ok $a->isa("HASH");
986114cf	71
3e44d7c6	72	ok $a->can("eat");
072cb3f5	73	ok ! $a->can("eat\0Except not!"), "->can is nul-clean.";
3e44d7c6 MS	74	ok ! $a->can("sleep");
	75	ok my $ref = $a->can("drink"); # returns a coderef
	76	is $a->$ref("tea"), "drinking tea"; # ... which works
	77	ok $ref = $a->can("sing");
444e39b5	78	eval { $a->$ref() };
3e44d7c6	79	ok $@; # ... but not if no actual subroutine
e09f3e01	80
3e44d7c6	81	ok (!Cedric->isa('Programmer'));
46e4b22b	82
3e44d7c6	83	ok (Cedric->isa('Human'));
46e4b22b GS	84
	85	push(@Cedric::ISA,'Programmer');
	86
3e44d7c6	87	ok (Cedric->isa('Programmer'));
46e4b22b GS	88
	89	{
	90	package Alice;
	91	base::->import('Programmer');
	92	}
	93
3e44d7c6 MS	94	ok $a->isa('Programmer');
3e44d7c6 MS	95	ok $a->isa("Female");
46e4b22b GS	96
	97	@Cedric::ISA = qw(Bob);
	98
3e44d7c6	99	ok (!Cedric->isa('Programmer'));
46e4b22b	100
e09f3e01 MG	101	my $b = 'abc';
	102	my @refs = qw(SCALAR SCALAR LVALUE GLOB ARRAY HASH CODE);
	103	my @vals = ( \$b, \3.14, \substr($b,1,1), \*b, [], {}, sub {} );
	104	for ($p=0; $p < @refs; $p++) {
	105	for ($q=0; $q < @vals; $q++) {
3e44d7c6	106	is UNIVERSAL::isa($vals[$p], $refs[$q]), ($p==$q or $p+$q==1);
e09f3e01 MG	107	};
	108	};
	109
68b40612	110	ok UNIVERSAL::can(23, "can");
cee59a6a FC	111	++${"23::foo"};
	112	ok UNIVERSAL::can("23", "can"), '"23" can can when the pack exists';
	113	ok UNIVERSAL::can(23, "can"), '23 can can when the pack exists';
4178f891 FC	114	sub IO::Handle::turn {}
	115	ok UNIVERSAL::can(*STDOUT, 'turn'), 'globs with IOs can';
	116	ok UNIVERSAL::can(\*STDOUT, 'turn'), 'globrefs with IOs can';
2bde9ae6	117	ok UNIVERSAL::can("STDOUT", 'turn'), 'IO barewords can';
e09f3e01	118
3e44d7c6	119	ok $a->can("VERSION");
e09f3e01	120
3e44d7c6 MS	121	ok $a->can("can");
3e44d7c6 MS	122	ok ! $a->can("export_tags"); # a method in Exporter
e09f3e01	123
3e44d7c6	124	cmp_ok eval { $a->VERSION }, '==', 2.718;
e09f3e01	125
3e44d7c6	126	ok ! (eval { $a->VERSION(2.719) });
ac0e6a2f	127	like $@, qr/^Alice version 2.719 required--this is only version 2.718 at /;
44a8e56a	128
3e44d7c6 MS	129	ok (eval { $a->VERSION(2.718) });
3e44d7c6 MS	130	is $@, '';
ff0cee69	131
c2a3bbbf FC	132	ok ! (eval { $a->VERSION("version") });
	133	like $@, qr/^Invalid version format/;
	134
	135	$aversion::VERSION = "version";
	136	ok ! (eval { aversion->VERSION(2.719) });
	137	like $@, qr/^Invalid version format/;
	138
e09f3e01	139	my $subs = join ' ', sort grep { defined &{"UNIVERSAL::$_"} } keys %UNIVERSAL::;
9d116dd7	140	if ('a' lt 'A') {
1178d2cf	141	is $subs, "can isa DOES VERSION";
9d116dd7	142	} else {
1178d2cf	143	is $subs, "DOES VERSION can isa";
9d116dd7	144	}
ff0cee69	145
3e44d7c6	146	ok $a->isa("UNIVERSAL");
ff0cee69	147
3e44d7c6	148	ok ! UNIVERSAL::isa([], "UNIVERSAL");
b4c2bf25	149
3e44d7c6	150	ok ! UNIVERSAL::can({}, "can");
b4c2bf25	151
3e44d7c6	152	ok UNIVERSAL::isa(Alice => "UNIVERSAL");
b4c2bf25	153
3e44d7c6	154	cmp_ok UNIVERSAL::can(Alice => "can"), '==', \&UNIVERSAL::can;
b4c2bf25	155
84902520	156	# now use UNIVERSAL.pm and see what changes
e09f3e01	157	eval "use UNIVERSAL";
ff0cee69	158
3e44d7c6	159	ok $a->isa("UNIVERSAL");
44a8e56a	160
46e4b22b	161	my $sub2 = join ' ', sort grep { defined &{"UNIVERSAL::$_"} } keys %UNIVERSAL::;
84902520	162	# XXX import being here is really a bug
9d116dd7	163	if ('a' lt 'A') {
4bf88892	164	is $sub2, "can import isa DOES VERSION";
9d116dd7	165	} else {
4bf88892	166	is $sub2, "DOES VERSION can import isa";
9d116dd7	167	}
44a8e56a	168
e09f3e01	169	eval 'sub UNIVERSAL::sleep {}';
3e44d7c6	170	ok $a->can("sleep");
44a8e56a	171
68b40612	172	ok UNIVERSAL::can($b, "can");
84902520	173
3e44d7c6	174	ok ! $a->can("export_tags"); # a method in Exporter
83f7a2bc	175
3e44d7c6	176	ok ! UNIVERSAL::isa("\xff\xff\xff\0", 'HASH');
ea8fae29 BS	177
ea8fae29 BS	178	{
253ecd6d RGS	179	# test isa() and can() on magic variables
253ecd6d RGS	180	"Human" =~ /(.*)/;
3e44d7c6 MS	181	ok $1->isa("Human");
3e44d7c6 MS	182	ok $1->can("eat");
253ecd6d RGS	183	package HumanTie;
	184	sub TIESCALAR { bless {} }
	185	sub FETCH { "Human" }
	186	tie my($x), "HumanTie";
3e44d7c6 MS	187	::ok $x->isa("Human");
3e44d7c6 MS	188	::ok $x->can("eat");
253ecd6d	189	}
a1d407e8 DM	190
	191	# bugid 3284
	192	# a second call to isa('UNIVERSAL') when @ISA is null failed due to caching
	193
	194	@X::ISA=();
	195	my $x = {}; bless $x, 'X';
3e44d7c6 MS	196	ok $x->isa('UNIVERSAL');
3e44d7c6 MS	197	ok $x->isa('UNIVERSAL');
2bfd5681 MS	198
	199
	200	# Check that the "historical accident" of UNIVERSAL having an import()
	201	# method doesn't effect anyone else.
	202	eval { Some::Package->import("bar") };
3e44d7c6 MS	203	is $@, '';
	204
	205
	206	# This segfaulted in a blead.
	207	fresh_perl_is('package Foo; Foo->VERSION; print "ok"', 'ok');
	208
1f656fcf FC	209	# So did this.
	210	fresh_perl_is('$:; UNIVERSAL::isa(":","Unicode::String");print "ok"','ok');
	211
cbc021f9	212	package Foo;
cbc021f9	213
4bf88892	214	sub DOES { 1 }
cbc021f9	215
	216	package Bar;
	217
	218	@Bar::ISA = 'Foo';
	219
	220	package Baz;
	221
	222	package main;
4bf88892 RGS	223	ok( Foo->DOES( 'bar' ), 'DOES() should call DOES() on class' );
	224	ok( Bar->DOES( 'Bar' ), '... and should fall back to isa()' );
	225	ok( Bar->DOES( 'Foo' ), '... even when inherited' );
	226	ok( Baz->DOES( 'Baz' ), '... even without inheriting any other DOES()' );
	227	ok( ! Baz->DOES( 'Foo' ), '... returning true or false appropriately' );
ae6d515f	228
072cb3f5 BF	229	ok( ! "T"->DOES( "T\0" ), 'DOES() is nul-clean' );
	230	ok( ! Baz->DOES( "Baz\0Boy howdy" ), 'DOES() is nul-clean' );
	231
ae6d515f RGS	232	package Pig;
	233	package Bodine;
	234	Bodine->isa('Pig');
	235	*isa = \&UNIVERSAL::isa;
	236	eval { isa({}, 'HASH') };
59e7186f RGS	237	::is($@, '', "*isa correctly found");
	238
	239	package main;
	240	eval { UNIVERSAL::DOES([], "foo") };
	241	like( $@, qr/Can't call method "DOES" on unblessed reference/,
	242	'DOES call error message says DOES, not isa' );
b91ba1f2 NC	243
	244	# Tests for can seem to be split between here and method.t
	245	# Add the verbatim perl code mentioned in the comments of
	246	# http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2001-05/msg01710.html
	247	# but never actually tested.
	248	is(UNIVERSAL->can("NoSuchPackage::foo"), undef);
5782d502 NC	249
	250	@splatt::ISA = 'zlopp';
	251	ok (splatt->isa('zlopp'));
	252	ok (!splatt->isa('plop'));
	253
	254	# This should reset the ->isa lookup cache
	255	@splatt::ISA = 'plop';
	256	# And here is the new truth.
	257	ok (!splatt->isa('zlopp'));
	258	ok (splatt->isa('plop'));
	259
cd477a63 RGS	260	use warnings "deprecated";
	261	{
	262	my $m;
	263	local $SIG{__WARN__} = sub { $m = $_[0] };
252143cd	264	eval "use UNIVERSAL 'can'";
1178d2cf DIM	265	like($@, qr/^UNIVERSAL does not export anything\b/,
	266	"error for UNIVERSAL->import('can')");
	267	is($m, undef,
	268	"no deprecation warning for UNIVERSAL->import('can')");
252143cd RS	269
	270	undef $m;
	271	eval "use UNIVERSAL";
1178d2cf DIM	272	is($@, "",
1178d2cf DIM	273	"no error for UNIVERSAL->import");
252143cd RS	274	is($m, undef,
252143cd RS	275	"no deprecation warning for UNIVERSAL->import");
cd477a63	276	}
27889255 B	277
	278	# Test: [perl #66112]: change @ISA inside sub isa
	279	{
	280	package RT66112::A;
	281
	282	package RT66112::B;
	283
	284	sub isa {
	285	my $self = shift;
	286	@ISA = qw/RT66112::A/;
	287	return $self->SUPER::isa(@_);
	288	}
	289
	290	package RT66112::C;
	291
	292	package RT66112::D;
	293
	294	sub isa {
	295	my $self = shift;
	296	@RT66112::E::ISA = qw/RT66112::A/;
	297	return $self->SUPER::isa(@_);
	298	}
	299
	300	package RT66112::E;
	301
	302	package main;
	303
	304	@RT66112::B::ISA = qw//;
	305	@RT66112::C::ISA = qw/RT66112::B/;
	306	@RT66112::T1::ISA = qw/RT66112::C/;
	307	ok(RT66112::T1->isa('RT66112::C'), "modify \@ISA in isa (RT66112::T1 isa RT66112::C)");
	308
	309	@RT66112::B::ISA = qw//;
	310	@RT66112::C::ISA = qw/RT66112::B/;
	311	@RT66112::T2::ISA = qw/RT66112::C/;
	312	ok(RT66112::T2->isa('RT66112::B'), "modify \@ISA in isa (RT66112::T2 isa RT66112::B)");
	313
	314	@RT66112::B::ISA = qw//;
	315	@RT66112::C::ISA = qw/RT66112::B/;
	316	@RT66112::T3::ISA = qw/RT66112::C/;
80ebaca2	317	ok(RT66112::T3->isa('RT66112::A'), "modify \@ISA in isa (RT66112::T3 isa RT66112::A)") or require mro, diag "@{mro::get_linear_isa('RT66112::T3')}";
27889255 B	318
	319	@RT66112::E::ISA = qw/RT66112::D/;
	320	@RT66112::T4::ISA = qw/RT66112::E/;
	321	ok(RT66112::T4->isa('RT66112::E'), "modify \@ISA in isa (RT66112::T4 isa RT66112::E)");
	322
	323	@RT66112::E::ISA = qw/RT66112::D/;
	324	@RT66112::T5::ISA = qw/RT66112::E/;
	325	ok(! RT66112::T5->isa('RT66112::D'), "modify \@ISA in isa (RT66112::T5 not isa RT66112::D)");
	326
	327	@RT66112::E::ISA = qw/RT66112::D/;
	328	@RT66112::T6::ISA = qw/RT66112::E/;
	329	ok(RT66112::T6->isa('RT66112::A'), "modify \@ISA in isa (RT66112::T6 isa RT66112::A)");
	330	}
68b40612 JL	331
	332	ok(Undeclared->can("can"));
	333	sub Undeclared::foo { }
	334	ok(Undeclared->can("foo"));
	335	ok(!Undeclared->can("something_else"));
61c2a935 JL	336
61c2a935 JL	337	ok(Undeclared->isa("UNIVERSAL"));
d70bfb04 JL	338
	339	# keep this at the end to avoid messing up earlier tests, since it modifies
	340	# @UNIVERSAL::ISA
	341	@UNIVERSAL::ISA = ('UniversalParent');
	342	{ package UniversalIsaTest1; }
	343	ok(UniversalIsaTest1->isa('UniversalParent'));
	344	ok(UniversalIsaTest2->isa('UniversalParent'));