This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Fix two local *ISA bugs
[perl5.git] / t / mro / basic.t
index 303708e..ab34fc2 100644 (file)
@@ -3,16 +3,9 @@
 use strict;
 use warnings;
 
-BEGIN {
-    unless (-d 'blib') {
-        chdir 't' if -d 't';
-        @INC = '../lib';
-    }
-}
+BEGIN { require q(./test.pl); } plan(tests => 59);
 
-use Test::More;
-
-plan tests => 8;
+require mro;
 
 {
     package MRO_A;
@@ -29,20 +22,34 @@ plan tests => 8;
     our @ISA = qw/MRO_D MRO_E/;
 }
 
+my @MFO_F_DFS = qw/MRO_F MRO_D MRO_A MRO_B MRO_C MRO_E/;
+my @MFO_F_C3 = qw/MRO_F MRO_D MRO_E MRO_A MRO_B MRO_C/;
 is(mro::get_mro('MRO_F'), 'dfs');
-is_deeply(mro::get_linear_isa('MRO_F'),
-    [qw/MRO_F MRO_D MRO_A MRO_B MRO_C MRO_E/]
-);
+ok(eq_array(
+    mro::get_linear_isa('MRO_F'), \@MFO_F_DFS
+));
+
+ok(eq_array(mro::get_linear_isa('MRO_F', 'dfs'), \@MFO_F_DFS));
+ok(eq_array(mro::get_linear_isa('MRO_F', 'c3'), \@MFO_F_C3));
+eval{mro::get_linear_isa('MRO_F', 'C3')};
+like($@, qr/^Invalid mro name: 'C3'/);
+
 mro::set_mro('MRO_F', 'c3');
 is(mro::get_mro('MRO_F'), 'c3');
-is_deeply(mro::get_linear_isa('MRO_F'),
-    [qw/MRO_F MRO_D MRO_E MRO_A MRO_B MRO_C/]
-);
+ok(eq_array(
+    mro::get_linear_isa('MRO_F'), \@MFO_F_C3
+));
+
+ok(eq_array(mro::get_linear_isa('MRO_F', 'dfs'), \@MFO_F_DFS));
+ok(eq_array(mro::get_linear_isa('MRO_F', 'c3'), \@MFO_F_C3));
+eval{mro::get_linear_isa('MRO_F', 'C3')};
+like($@, qr/^Invalid mro name: 'C3'/);
 
-my @isarev = sort { $a cmp $b } mro::get_isarev('MRO_B');
-is_deeply(\@isarev,
+my @isarev = sort { $a cmp $b } @{mro::get_isarev('MRO_B')};
+ok(eq_array(
+    \@isarev,
     [qw/MRO_D MRO_E MRO_F/]
-);
+));
 
 ok(!mro::is_universal('MRO_B'));
 
@@ -50,4 +57,316 @@ ok(!mro::is_universal('MRO_B'));
 ok(mro::is_universal('MRO_B'));
 
 @UNIVERSAL::ISA = ();
-ok(mro::is_universal('MRO_B'));
+ok(!mro::is_universal('MRO_B'));
+
+# is_universal, get_mro, and get_linear_isa should
+# handle non-existent packages sanely
+ok(!mro::is_universal('Does_Not_Exist'));
+is(mro::get_mro('Also_Does_Not_Exist'), 'dfs');
+ok(eq_array(
+    mro::get_linear_isa('Does_Not_Exist_Three'),
+    [qw/Does_Not_Exist_Three/]
+));
+
+# Assigning @ISA via globref
+{
+    package MRO_TestBase;
+    sub testfunc { return 123 }
+    package MRO_TestOtherBase;
+    sub testfunctwo { return 321 }
+    package MRO_M; our @ISA = qw/MRO_TestBase/;
+}
+*MRO_N::ISA = *MRO_M::ISA;
+is(eval { MRO_N->testfunc() }, 123);
+
+# XXX TODO (when there's a way to backtrack through a glob's aliases)
+# push(@MRO_M::ISA, 'MRO_TestOtherBase');
+# is(eval { MRO_N->testfunctwo() }, 321);
+
+# Simple DESTROY Baseline
+{
+    my $x = 0;
+    my $obj;
+
+    {
+        package DESTROY_MRO_Baseline;
+        sub new { bless {} => shift }
+        sub DESTROY { $x++ }
+
+        package DESTROY_MRO_Baseline_Child;
+        our @ISA = qw/DESTROY_MRO_Baseline/;
+    }
+
+    $obj = DESTROY_MRO_Baseline->new();
+    undef $obj;
+    is($x, 1);
+
+    $obj = DESTROY_MRO_Baseline_Child->new();
+    undef $obj;
+    is($x, 2);
+}
+
+# Dynamic DESTROY
+{
+    my $x = 0;
+    my $obj;
+
+    {
+        package DESTROY_MRO_Dynamic;
+        sub new { bless {} => shift }
+
+        package DESTROY_MRO_Dynamic_Child;
+        our @ISA = qw/DESTROY_MRO_Dynamic/;
+    }
+
+    $obj = DESTROY_MRO_Dynamic->new();
+    undef $obj;
+    is($x, 0);
+
+    $obj = DESTROY_MRO_Dynamic_Child->new();
+    undef $obj;
+    is($x, 0);
+
+    no warnings 'once';
+    *DESTROY_MRO_Dynamic::DESTROY = sub { $x++ };
+
+    $obj = DESTROY_MRO_Dynamic->new();
+    undef $obj;
+    is($x, 1);
+
+    $obj = DESTROY_MRO_Dynamic_Child->new();
+    undef $obj;
+    is($x, 2);
+}
+
+# clearing @ISA in different ways
+#  some are destructive to the package, hence the new
+#  package name each time
+{
+    no warnings 'uninitialized';
+    {
+        package ISACLEAR;
+        our @ISA = qw/XX YY ZZ/;
+    }
+    # baseline
+    ok(eq_array(mro::get_linear_isa('ISACLEAR'),[qw/ISACLEAR XX YY ZZ/]));
+
+    # this looks dumb, but it preserves existing behavior for compatibility
+    #  (undefined @ISA elements treated as "main")
+    $ISACLEAR::ISA[1] = undef;
+    ok(eq_array(mro::get_linear_isa('ISACLEAR'),[qw/ISACLEAR XX main ZZ/]));
+
+    # undef the array itself
+    undef @ISACLEAR::ISA;
+    ok(eq_array(mro::get_linear_isa('ISACLEAR'),[qw/ISACLEAR/]));
+
+    # Now, clear more than one package's @ISA at once
+    {
+        package ISACLEAR1;
+        our @ISA = qw/WW XX/;
+
+        package ISACLEAR2;
+        our @ISA = qw/YY ZZ/;
+    }
+    # baseline
+    ok(eq_array(mro::get_linear_isa('ISACLEAR1'),[qw/ISACLEAR1 WW XX/]));
+    ok(eq_array(mro::get_linear_isa('ISACLEAR2'),[qw/ISACLEAR2 YY ZZ/]));
+    (@ISACLEAR1::ISA, @ISACLEAR2::ISA) = ();
+
+    ok(eq_array(mro::get_linear_isa('ISACLEAR1'),[qw/ISACLEAR1/]));
+    ok(eq_array(mro::get_linear_isa('ISACLEAR2'),[qw/ISACLEAR2/]));
+
+    # [perl #49564]  This is a pretty obscure way of clearing @ISA but
+    # it tests a regression that affects XS code calling av_clear too.
+    {
+        package ISACLEAR3;
+        our @ISA = qw/WW XX/;
+    }
+    ok(eq_array(mro::get_linear_isa('ISACLEAR3'),[qw/ISACLEAR3 WW XX/]));
+    {
+        package ISACLEAR3;
+        reset 'I';
+    }
+    ok(eq_array(mro::get_linear_isa('ISACLEAR3'),[qw/ISACLEAR3/]));
+}
+
+# Check that recursion bails out "cleanly" in a variety of cases
+# (as opposed to say, bombing the interpreter or something)
+{
+    my @recurse_codes = (
+        '@MRO_R1::ISA = "MRO_R2"; @MRO_R2::ISA = "MRO_R1";',
+        '@MRO_R3::ISA = "MRO_R4"; push(@MRO_R4::ISA, "MRO_R3");',
+        '@MRO_R5::ISA = "MRO_R6"; @MRO_R6::ISA = qw/XX MRO_R5 YY/;',
+        '@MRO_R7::ISA = "MRO_R8"; push(@MRO_R8::ISA, qw/XX MRO_R7 YY/)',
+    );
+    foreach my $code (@recurse_codes) {
+        eval $code;
+        ok($@ =~ /Recursive inheritance detected/);
+    }
+}
+
+# Check that SUPER caches get invalidated correctly
+{
+    {
+        package SUPERTEST;
+        sub new { bless {} => shift }
+        sub foo { $_[1]+1 }
+
+        package SUPERTEST::MID;
+        our @ISA = 'SUPERTEST';
+
+        package SUPERTEST::KID;
+        our @ISA = 'SUPERTEST::MID';
+        sub foo { my $s = shift; $s->SUPER::foo(@_) }
+
+        package SUPERTEST::REBASE;
+        sub foo { $_[1]+3 }
+    }
+
+    my $stk_obj = SUPERTEST::KID->new();
+    is($stk_obj->foo(1), 2);
+    { no warnings 'redefine';
+      *SUPERTEST::foo = sub { $_[1]+2 };
+    }
+    is($stk_obj->foo(2), 4);
+    @SUPERTEST::MID::ISA = 'SUPERTEST::REBASE';
+    is($stk_obj->foo(3), 6);
+}
+
+{ 
+  {
+    # assigning @ISA via arrayref to globref RT 60220
+    package P1;
+    sub new { bless {}, shift }
+    
+    package P2;
+  }
+  *{P2::ISA} = [ 'P1' ];
+  my $foo = P2->new;
+  ok(!eval { $foo->bark }, "no bark method");
+  no warnings 'once';  # otherwise it'll bark about P1::bark used only once
+  *{P1::bark} = sub { "[bark]" };
+  is(scalar eval { $foo->bark }, "[bark]", "can bark now");
+}
+
+{
+  # assigning @ISA via arrayref then modifying it RT 72866
+  {
+    package Q1;
+    sub foo {  }
+
+    package Q2;
+    sub bar { }
+
+    package Q3;
+  }
+  push @Q3::ISA, "Q1";
+  can_ok("Q3", "foo");
+  *Q3::ISA = [];
+  push @Q3::ISA, "Q1";
+  can_ok("Q3", "foo");
+  *Q3::ISA = [];
+  push @Q3::ISA, "Q2";
+  can_ok("Q3", "bar");
+  ok(!Q3->can("foo"), "can't call foo method any longer");
+}
+
+{
+    # test mro::method_changed_in
+    my $count = mro::get_pkg_gen("MRO_A");
+    mro::method_changed_in("MRO_A");
+    my $count_new = mro::get_pkg_gen("MRO_A");
+
+    is($count_new, $count + 1);
+}
+
+{
+    # test if we can call mro::invalidate_all_method_caches;
+    eval {
+        mro::invalidate_all_method_caches();
+    };
+    is($@, "");
+}
+
+{
+    # @main::ISA
+    no warnings 'once';
+    @main::ISA = 'parent';
+    my $output = '';
+    *parent::do = sub { $output .= 'parent' };
+    *parent2::do = sub { $output .= 'parent2' };
+    main->do;
+    @main::ISA = 'parent2';
+    main->do;
+    is $output, 'parentparent2', '@main::ISA is magical';
+}
+
+{
+    # Undefining *ISA, then modifying @ISA
+    # This broke Class::Trait. See [perl #79024].
+    {package Class::Trait::Base}
+    no strict 'refs';
+    undef   *{"Extra::TSpouse::ISA"};
+    'Extra::TSpouse'->isa('Class::Trait::Base'); # cache the mro
+    unshift @{"Extra::TSpouse::ISA"}, 'Class::Trait::Base';
+    ok 'Extra::TSpouse'->isa('Class::Trait::Base'),
+     'a isa b after undef *a::ISA and @a::ISA modification';
+}
+
+{
+    # Deleting $package::{ISA}
+    # Broken in 5.10.0; fixed in 5.13.7
+    @Blength::ISA = 'Bladd';
+    delete $Blength::{ISA};
+    ok !Blength->isa("Bladd"), 'delete $package::{ISA}';
+}
+
+{
+    # Undefining stashes
+    @Thrext::ISA = "Thwit";
+    @Thwit::ISA = "Sile";
+    undef %Thwit::;
+    ok !Thrext->isa('Sile'), 'undef %package:: updates subclasses';
+}
+
+{
+    # Obliterating @ISA via glob assignment
+    # Broken in 5.14.0; fixed in 5.17.2
+    @Gwythaint::ISA = "Fantastic::Creature";
+    undef *This_glob_haD_better_not_exist; # paranoia; must have no array
+    *Gwythaint::ISA = *This_glob_haD_better_not_exist;
+    ok !Gwythaint->isa("Fantastic::Creature"),
+       'obliterating @ISA via glob assignment';
+}
+
+{
+    # Autovivifying @ISA via @{*ISA}
+    no warnings;
+    undef *fednu::ISA;
+    @{*fednu::ISA} = "pyfg";
+    ok +fednu->isa("pyfg"), 'autovivifying @ISA via *{@ISA}';
+}
+
+{
+    sub Detached::method;
+    my $h = delete $::{"Detached::"};
+    eval { local *Detached::method };
+    is $@, "", 'localising gv-with-cv belonging to detached package';
+}
+
+{
+    # *ISA localisation
+    @il::ISA = "ilsuper";
+    sub ilsuper::can { "puree" }
+    sub il::tomatoes;
+    {
+        local *il::ISA;
+        is +il->can("tomatoes"), \&il::tomatoes, 'local *ISA';
+    }
+    is "il"->can("tomatoes"), "puree", 'local *ISA unwinding';
+    {
+        local *il::ISA = [];
+        is +il->can("tomatoes"), \&il::tomatoes, 'local *ISA = []';
+    }
+    is "il"->can("tomatoes"), "puree", 'local *ISA=[] unwinding';
+}