package main;
$| = 1;
-BEGIN { require './test.pl' }
-plan tests => 5190;
+BEGIN { require './test.pl'; require './charset_tools.pl' }
+plan tests => 5326;
use Scalar::Util qw(tainted);
is(ref $a, "Oscalar");
is($copies, 1);
-eval q[package Oscalar; use overload ('+=' => sub {$ {$_[0]} += 3*"$_[1]";
+eval q[package Oscalar; use overload ('+=' => sub {$ {$_[0]} += 3*$_[1];
$_[0] } ) ];
$c=new Oscalar; # Cause rehash
$na = 0;
$na = eval { ~$aI };
-like($@, '');
+is($@, '');
bless \$x, OscalarI;
main::ok($x+0 =~ qr/Recurse=ARRAY/);
}
-# BugID 20010422.003
+# BugID 20010422.003 (#6872)
package Foo;
use overload
}
{
+ # Check readonliness of constants, whether shared hash key
+ # scalars or no (brought up in bug #109744)
+ BEGIN { overload::constant integer => sub { "main" }; }
+ eval { ${\5} = 'whatever' };
+ like $@, qr/^Modification of a read-only value attempted at /,
+ 'constant overloading makes read-only constants';
+ BEGIN { overload::constant integer => sub { __PACKAGE__ }; }
+ eval { ${\5} = 'whatever' };
+ like $@, qr/^Modification of a read-only value attempted at /,
+ '... even with shared hash key scalars';
+}
+
+{
package Sklorsh;
use overload
bool => sub { shift->is_cool };
for my $sub (keys %subs) {
+ no warnings 'experimental::smartmatch';
my $term = $subs{$sub};
my $t = sprintf $term, '$_[0][0]';
my $e ="sub { \$funcs .= '($sub)'; my \$r; if (\$use_int) {"
? "-\$_[0][0]"
: "$_[3](\$_[0][0])";
my $r;
+ no warnings 'experimental::smartmatch';
if ($use_int) {
use integer; $r = eval $e;
}
$use_int = ($int ne '');
my $plain = $tainted_val;
my $plain_term = $int . sprintf $sub_term, '$plain';
- my $exp = eval $plain_term;
+ my $exp = do {no warnings 'experimental::smartmatch'; eval $plain_term };
diag("eval of plain_term <$plain_term> gave <$@>") if $@;
is(tainted($exp), $exp_taint,
"<$plain_term> taint of expected return");
my $res_term = $int . sprintf $sub_term, $var;
my $desc = "<$res_term> $ov_pkg" ;
- my $res = eval $res_term;
+ my $res = do { no warnings 'experimental::smartmatch'; eval $res_term };
diag("eval of res_term $desc gave <$@>") if $@;
# uniquely, the inc/dec ops return the original
# ref rather than a copy, so stringify it to
}
package NCmp;
- use base 'CmpBase';
+ use parent '-norequire', 'CmpBase';
use overload '<=>' => 'cmp';
package SCmp;
- use base 'CmpBase';
+ use parent '-norequire', 'CmpBase';
use overload 'cmp' => 'cmp';
package main;
? $nomethod . "=>'nomethod'," : '';
eval qq{
package NuMB$fall$nomethod;
- use base qw/NuMB/;
+ use parent '-norequire', qw/NuMB/;
use overload $nomethod_decl
fallback => $fall;
};
$o->[0] = 1;
$c = 0;
- ::ok("\xc4\x80" =~ "^\x{100}\$",
+ ::ok(main::byte_utf8a_to_utf8n("\xc4\x80") =~ "^\x{100}\$",
"regex stringify utf8=1 ol=0 bytes=1");
- ::ok("\xc4\x80" =~ $o, "regex stringify utf8=1 ol=1 bytes=1");
+ ::ok(main::byte_utf8a_to_utf8n("\xc4\x80") =~ $o, "regex stringify utf8=1 ol=1 bytes=1");
::is($c, 1, "regex stringify utf8=1 ol=1 bytes=1 count");
}
}
+{
+ # Making Regexp class overloaded: avoid infinite recursion.
+ # Do this in a separate process since it, well, overloads Regexp!
+ fresh_perl_is(
+ <<'EOF',
+package Regexp;
+use overload q{""} => sub {$_[0] };
+package main;
+my $r1 = qr/1/;
+my $r2 = qr/ABC$r1/;
+print $r2,"\n";
+EOF
+ '(?^:ABC(?^:1))',
+ { stderr => 1 },
+ 'overloaded REGEXP'
+ );
+}
+
+{
+ # RT #121362
+ # splitting the stash HV while rebuilding the overload cache gave
+ # valgrind errors. This test code triggers such a split. It doesn't
+ # actually test anything; its just there for valgrind to spot
+ # problems.
+
+ package A_121362;
+
+ sub stringify { }
+ use overload '""' => 'stringify';
+
+ package B_121362;
+ our @ISA = qw(A_121362);
+
+ package main;
+
+ my $x = bless { }, 'B_121362';
+
+ for ('a'..'z') {
+ delete $B_121362::{stringify}; # delete cache entry
+ no strict 'refs';
+ *{"B_121362::$_"} = sub { }; # increase size of %B_121362
+ my $y = $x->{value}; # trigger cache add to %B_121362
+ }
+ pass("RT 121362");
+}
+
+package refsgalore {
+ use overload
+ '${}' => sub { \42 },
+ '@{}' => sub { [43] },
+ '%{}' => sub { { 44 => 45 } },
+ '&{}' => sub { sub { 46 } };
+}
+{
+ use feature 'postderef';
+ tell myio; # vivifies *myio{IO} at compile time
+ use constant ioref => bless *myio{IO}, refsgalore::;
+ is ioref->$*, 42, '(overloaded constant that is not a scalar ref)->$*';
+ is ioref->[0], 43, '(ovrld constant that is not an array ref)->[0]';
+ is ioref->{44}, 45, "(ovrld const that is not a hash ref)->{key}";
+ is ioref->(), 46, '(overloaded constant that is not a sub ref)->()';
+}
+
+package xstack { use overload 'x' => sub { shift . " x " . shift },
+ '""'=> sub { "xstack" } }
+is join(",", 1..3, scalar((bless([], 'xstack')) x 3, 1), 4..6),
+ "1,2,3,1,4,5,6",
+ '(...)x... in void cx with x overloaded [perl #121827]';
+
+package bitops {
+ our @o;
+ use overload do {
+ my %o;
+ for my $o (qw(& | ^ ~ &. |. ^. ~. &= |= ^= &.= |.= ^.=)) {
+ $o{$o} = sub {
+ ::ok !defined $_[3], "undef (or nonexistent) arg 3 for $o";
+ push @o, $o, scalar @_, $_[4]//'u';
+ $_[0]
+ }
+ }
+ %o, '=' => sub { bless [] };
+ }
+}
+{
+ use experimental 'bitwise';
+ my $o = bless [], bitops::;
+ $_ = $o & 0;
+ $_ = $o | 0;
+ $_ = $o ^ 0;
+ $_ = ~$o;
+ $_ = $o &. 0;
+ $_ = $o |. 0;
+ $_ = $o ^. 0;
+ $_ = ~.$o;
+ $o &= 0;
+ $o |= 0;
+ $o ^= 0;
+ $o &.= 0;
+ $o |.= 0;
+ $o ^.= 0;
+ # elems are in triplets: op, length of @_, numeric? (1/u for y/n)
+ is "@bitops::o", '& 5 1 | 5 1 ^ 5 1 ~ 5 1 &. 3 u |. 3 u ^. 3 u ~. 3 u ' . '&= 5 1 |= 5 1 ^= 5 1 &.= 3 u |.= 3 u ^.= 3 u',
+ 'experimental "bitwise" ops'
+}
+package bitops2 {
+ our @o;
+ use overload
+ nomethod => sub { push @o, $_[3], scalar @_, $_[4]//'u'; $_[0] },
+ '=' => sub { bless [] };
+}
+{
+ use experimental 'bitwise';
+ my $o = bless [], bitops2::;
+ $_ = $o & 0;
+ $_ = $o | 0;
+ $_ = $o ^ 0;
+ $_ = ~$o;
+ $_ = $o &. 0;
+ $_ = $o |. 0;
+ $_ = $o ^. 0;
+ $_ = ~.$o;
+ $o &= 0;
+ $o |= 0;
+ $o ^= 0;
+ $o &.= 0;
+ $o |.= 0;
+ $o ^.= 0;
+ # elems are in triplets: op, length of @_, numeric? (1/u for y/n)
+ is "@bitops2::o", '& 5 1 | 5 1 ^ 5 1 ~ 5 1 &. 4 u |. 4 u ^. 4 u ~. 4 u ' . '&= 5 1 |= 5 1 ^= 5 1 &.= 4 u |.= 4 u ^.= 4 u',
+ 'experimental "bitwise" ops with nomethod'
+}
+
+package length_utf8 {
+ use overload '""' => sub { "\x{100}" };
+ my $o = bless [];
+print length $o, "\n";
+
+ ::is length($o), 1, "overloaded utf8 length";
+ ::is "$o", "\x{100}", "overloaded utf8 value";
+}
+
+
{ # undefining the overload stash -- KEEP THIS TEST LAST
package ant;
use overload '+' => 'onion';
}
-# EOF
+# test various aspects of string concat overloading, especially where
+# multiple concats etc are optimised into a single multiconcat op
+
+package Concat {
+
+ my $id;
+
+ # append a brief description of @_ to $id
+ sub id {
+ my @a = map ref $_ ? "[" . $_->[0] . "]" :
+ !defined $_ ? "u" :
+ $_,
+ @_;
+ $id .= '(' . join (',', @a) . ')';
+ }
+
+ use overload
+ '.' => sub {
+ id('.', @_);
+ my ($l, $r, $rev) = @_;
+ ($l, $r) = map ref $_ ? $_->[0] : $_, $l, $r;
+ ($l,$r) = ($r, $l) if $rev;
+ bless [ $l . $r ];
+ },
+
+ '.=' => sub {
+ id('.=', @_);
+ my ($l, $r, $rev) = @_;
+ my ($ll, $rr) = map ref $_ ? $_->[0] : $_, $l, $r;
+ die "Unexpected reverse in .=" if $rev;
+ $l->[0] .= ref $r ? $r->[0] : $r;
+ $l;
+ },
+
+ '=' => sub {
+ id('=', @_);
+ bless [ $_[0][0] ];
+ },
+
+ '""' => sub {
+ id('""', @_);
+ $_[0][0];
+ },
+ ;
+
+ my $a = 'a';
+ my $b = 'b';
+ my $c = 'c';
+ my $A = bless [ 'A' ];
+ my $B = bless [ 'B' ];
+ my $C = bless [ 'C' ];
+
+ my ($r, $R);
+
+
+ # like c, but with $is_ref set to 1
+ sub c {
+ my ($expr, $expect, $exp_id) = @_;
+ cc($expr, $expect, 1, $exp_id);
+ }
+
+ # eval $expr, and see if it returns $expect, and whether
+ # the returned value is a ref ($is_ref). Finally, check that
+ # $id, which has accumulated info from all overload method calls,
+ # matches $exp_id.
+
+ sub cc {
+ my ($expr, $expect, $is_ref, $exp_id) = @_;
+
+ $id = '';
+ $r = 'r';
+ $R = bless ['R'];
+
+ my $got = eval $expr;
+ die "eval failed: $@" if $@;
+ ::is "$got", $expect, "expect: $expr";
+ ::is $id, $exp_id, "id: $expr";
+ ::is ref($got), ($is_ref ? 'Concat' : ''), "is_ref: $expr";
+ }
+
+ # single concats
+
+ c '$r=$A.$b', 'Ab', '(.,[A],b,)("",[Ab],u,)';
+ c '$r=$a.$B', 'aB', '(.,[B],a,1)("",[aB],u,)';
+ c '$r=$A.$B', 'AB', '(.,[A],[B],)("",[AB],u,)';
+ c '$R.=$a', 'Ra', '(.=,[R],a,u)("",[Ra],u,)';
+ c '$R.=$A', 'RA', '(.=,[R],[A],u)("",[RA],u,)';
+
+ # two concats
+
+ c '$r=$A.$b.$c', 'Abc', '(.,[A],b,)(.=,[Ab],c,u)("",[Abc],u,)';
+ c '$r=$A.($b.$c)', 'Abc', '(.,[A],bc,)("",[Abc],u,)';
+ c '$r=$a.$B.$c', 'aBc', '(.,[B],a,1)(.=,[aB],c,u)("",[aBc],u,)';
+ c '$r=$a.($B.$c)', 'aBc', '(.,[B],c,)(.,[Bc],a,1)("",[aBc],u,)';
+ c '$r=$a.$b.$C', 'abC', '(.,[C],ab,1)("",[abC],u,)';
+ c '$r=$a.($b.$C)', 'abC', '(.,[C],b,1)(.,[bC],a,1)("",[abC],u,)';
+
+ # two concats plus mutator
+
+ c '$r.=$A.$b.$c', 'rAbc', '(.,[A],b,)(.=,[Ab],c,u)(.,[Abc],r,1)'
+ .'("",[rAbc],u,)';
+ c '$r.=$A.($b.$c)', 'rAbc', '(.,[A],bc,)(.,[Abc],r,1)("",[rAbc],u,)';
+ c '$r.=$a.$B.$c', 'raBc', '(.,[B],a,1)(.=,[aB],c,u)(.,[aBc],r,1)'
+ .'("",[raBc],u,)';
+ c '$r.=$a.($B.$c)', 'raBc', '(.,[B],c,)(.,[Bc],a,1)(.,[aBc],r,1)'
+ .'("",[raBc],u,)';
+ c '$r.=$a.$b.$C', 'rabC', '(.,[C],ab,1)(.,[abC],r,1)("",[rabC],u,)';
+ c '$r.=$a.($b.$C)', 'rabC', '(.,[C],b,1)(.,[bC],a,1)(.,[abC],r,1)'
+ .'("",[rabC],u,)';
+
+ c '$R.=$A.$b.$c', 'RAbc', '(.,[A],b,)(.=,[Ab],c,u)(.=,[R],[Abc],u)'
+ .'("",[RAbc],u,)';
+ c '$R.=$A.($b.$c)', 'RAbc', '(.,[A],bc,)(.=,[R],[Abc],u)("",[RAbc],u,)';
+ c '$R.=$a.$B.$c', 'RaBc', '(.,[B],a,1)(.=,[aB],c,u)(.=,[R],[aBc],u)'
+ .'("",[RaBc],u,)';
+ c '$R.=$a.($B.$c)', 'RaBc', '(.,[B],c,)(.,[Bc],a,1)(.=,[R],[aBc],u)'
+ .'("",[RaBc],u,)';
+ c '$R.=$a.$b.$C', 'RabC', '(.,[C],ab,1)(.=,[R],[abC],u)("",[RabC],u,)';
+ c '$R.=$a.($b.$C)', 'RabC', '(.,[C],b,1)(.,[bC],a,1)(.=,[R],[abC],u)'
+ .'("",[RabC],u,)';
+
+ # concat over assign
+
+ c '($R.=$a).$B.$c', 'RaBc', '(.=,[R],a,u)(.,[Ra],[B],)(.=,[RaB],c,u)'
+ .'("",[RaBc],u,)';
+ ::is "$R", "Ra", 'R in concat over assign';
+
+
+ # nested mutators
+
+ c '(($R.=$a).=$b).=$c', 'Rabc', '(.=,[R],a,u)(=,[Ra],u,)(.=,[Ra],b,u)'
+ . '(=,[Rab],u,)(.=,[Rab],c,u)("",[Rabc],u,)';
+ c '(($R.=$a).=$B).=$c', 'RaBc', '(.=,[R],a,u)(=,[Ra],u,)(.=,[Ra],[B],u)'
+ . '(=,[RaB],u,)(.=,[RaB],c,u)("",[RaBc],u,)';
+
+ # plain SV on both LHS and RHS with RHS object
+
+ c '$r=$r.$A.$r', 'rAr', '(.,[A],r,1)(.=,[rA],r,u)("",[rAr],u,)';
+ c '$r.=$r.$A.$r', 'rrAr', '(.,[A],r,1)(.=,[rA],r,u)(.,[rAr],r,1)'
+ .'("",[rrAr],u,)';
+
+ # object on both LHS and RHS
+
+ c '$R.=$R', 'RR', '(.=,[R],[R],u)("",[RR],u,)';
+ c '$R.=$R.$b.$c', 'RRbc', '(.,[R],b,)(.=,[Rb],c,u)(.=,[R],[Rbc],u)'
+ .'("",[RRbc],u,)';
+ c '$R.=$a.$R.$c', 'RaRc', '(.,[R],a,1)(.=,[aR],c,u)(.=,[R],[aRc],u)'
+ .'("",[RaRc],u,)';
+ c '$R.=$a.$b.$R', 'RabR', '(.,[R],ab,1)(.=,[R],[abR],u)("",[RabR],u,)';
+
+
+ # sprintf shouldn't do concat overloading
+
+ cc '$r=sprintf("%s%s%s",$a,$B,$c)', 'aBc', 0, '("",[B],u,)';
+ cc '$R=sprintf("%s%s%s",$a,$B,$c)', 'aBc', 0, '("",[B],u,)';
+ cc '$r.=sprintf("%s%s%s",$a,$B,$c)', 'raBc', 0, '("",[B],u,)';
+ cc '$R.=sprintf("%s%s%s",$a,$B,$c)', 'RaBc', 1, '("",[B],u,)(.=,[R],aBc,u)'
+ .'("",[RaBc],u,)';
+}
https://perl5.git.perl.org / perl5.git / blobdiff