This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
detect sub attributes following a signature
[perl5.git] / t / op / tie_fetch_count.t
diff --git a/t/op/tie_fetch_count.t b/t/op/tie_fetch_count.t
index f4527a1..d8b906d 100644 (file)
--- a/t/op/tie_fetch_count.t
+++ b/t/op/tie_fetch_count.t
@@ -5,14 +5,17 @@
 
 BEGIN {
     chdir 't' if -d 't';
-    @INC = '../lib';
     require './test.pl';
-    plan (tests => 218);
+    set_up_inc('../lib');
 }
 
+plan (tests => 343);
+
 use strict;
 use warnings;
 
+my $can_config = eval { require Config; 1 };
+
 my $count = 0;
 
 # Usage:
@@ -28,6 +31,7 @@ sub STORE { unshift @{$_[0]}, $_[1] }
 sub check_count {
     my $op = shift;
     my $expected = shift() // 1;
+    local $::Level = $::Level + 1;
     is $count, $expected,
         "FETCH called " . (
           $expected == 1 ? "just once" : 
@@ -43,6 +47,7 @@ tie my $var => 'main', 1;
 
 # Assignment.
 $dummy  =  $var         ; check_count "=";
+*dummy  =  $var         ; check_count '*glob = $tied';
 
 # Unary +/-
 $dummy  = +$var         ; check_count "unary +";
@@ -60,6 +65,11 @@ $dummy  =  $var  >>   1 ; check_count '>>';
 $dummy  =  $var   x   1 ; check_count 'x';
 @dummy  = ($var)  x   1 ; check_count 'x';
 $dummy  =  $var   .   1 ; check_count '.';
+@dummy  =  $var  ..   1 ; check_count '$tied..1';
+@dummy  =   1    .. $var; check_count '1..$tied';
+tie my $v42 => 'main', "z";
+@dummy  =  $v42  ..  "a"; check_count '$tied.."a"';
+@dummy  =  "a"   .. $v42; check_count '"a"..$tied';
  
 # Pre/post in/decrement
            $var ++      ; check_count 'post ++';
@@ -109,48 +119,58 @@ $dummy  =   abs $var    ; check_count 'abs';
 $dummy  =   log $var    ; check_count 'log';
 $dummy  =  sqrt $var    ; check_count 'sqrt';
 $dummy  =   int $var    ; check_count 'int';
+SKIP: {
+    unless ($can_config) {
+        skip "no config (no infinity for int)", 1;
+    }
+    unless ($Config::Config{d_double_has_inf}) {
+        skip "no infinity for int", 1;
+    }
+$var = "inf" for 1..5;
+$dummy  =   int $var    ; check_count 'int $tied_inf';
+}
 $dummy  = atan2 $var, 1 ; check_count 'atan2';
 
 # Readline/glob
 tie my $var0, "main", \*DATA;
 $dummy  = <$var0>       ; check_count '<readline>';
-$dummy  = <${var}>      ; check_count '<glob>';
+$var    = \1;
+$var   .= <DATA>        ; check_count '$tiedref .= <rcatline>';
+$var    = "tied";
+$var   .= <DATA>        ; check_count '$tiedstr .= <rcatline>';
+$var    = *foo;
+$var   .= <DATA>        ; check_count '$tiedglob .= <rcatline>';
+{   no warnings "glob";
+    $dummy  = <${var}>      ; check_count '<glob>';
+}
 
 # File operators
-$dummy  = -r $var       ; check_count '-r';
-$dummy  = -w $var       ; check_count '-w';
-$dummy  = -x $var       ; check_count '-x';
-$dummy  = -o $var       ; check_count '-o';
-$dummy  = -R $var       ; check_count '-R';
-$dummy  = -W $var       ; check_count '-W';
-$dummy  = -X $var       ; check_count '-X';
-$dummy  = -O $var       ; check_count '-O';
-$dummy  = -e $var       ; check_count '-e';
-$dummy  = -z $var       ; check_count '-z';
-$dummy  = -s $var       ; check_count '-s';
-$dummy  = -f $var       ; check_count '-f';
-$dummy  = -d $var       ; check_count '-d';
+for (split //, 'rwxoRWXOezsfdpSbctugkTBMAC') {
+    no warnings 'unopened';
+    $dummy  = eval "-$_ \$var"; check_count "-$_";
+    # Make $var hold a glob:
+    $var = *dummy; $dummy = $var; $count = 0;
+    $dummy  = eval "-$_ \$var"; check_count "-$_ \$tied_glob";
+    next if /[guk]/;
+    $var = *dummy; $dummy = $var; $count = 0;
+    eval "\$dummy = -$_ \\\$var";
+    check_count "-$_ \\\$tied_glob";
+}
 $dummy  = -l $var       ; check_count '-l';
-$dummy  = -p $var       ; check_count '-p';
-$dummy  = -S $var       ; check_count '-S';
-$dummy  = -b $var       ; check_count '-b';
-$dummy  = -c $var       ; check_count '-c';
-$dummy  = -t $var       ; check_count '-t';
-$dummy  = -u $var       ; check_count '-u';
-$dummy  = -g $var       ; check_count '-g';
-$dummy  = -k $var       ; check_count '-k';
-$dummy  = -T $var       ; check_count '-T';
-$dummy  = -B $var       ; check_count '-B';
-$dummy  = -M $var       ; check_count '-M';
-$dummy  = -A $var       ; check_count '-A';
-$dummy  = -C $var       ; check_count '-C';
+$var = "test.pl";
+$dummy  = -e -e -e $var ; check_count '-e -e';
 
 # Matching
 $_ = "foo";
 $dummy  =  $var =~ m/ / ; check_count 'm//';
 $dummy  =  $var =~ s/ //; check_count 's///';
-$dummy  =  $var ~~    1 ; check_count '~~';
+{
+    no warnings 'experimental::smartmatch';
+    $dummy  =  $var ~~    1 ; check_count '~~';
+}
 $dummy  =  $var =~ y/ //; check_count 'y///';
+           $var = \1;
+$dummy  =  $var =~y/ /-/; check_count '$ref =~ y///';
            /$var/       ; check_count 'm/pattern/';
            /$var foo/   ; check_count 'm/$tied foo/';
           s/$var//      ; check_count 's/pattern//';
@@ -162,13 +182,11 @@ tie my $var1 => 'main', \1;
 $dummy  = $$var1        ; check_count '${}';
 tie my $var2 => 'main', [];
 $dummy  = @$var2        ; check_count '@{}';
-$dummy  = shift $var2   ; check_count 'shift arrayref';
 tie my $var3 => 'main', {};
 $dummy  = %$var3        ; check_count '%{}';
-$dummy  = keys $var3    ; check_count 'keys hashref';
 {
     no strict 'refs';
-    tie my $var4 => 'main', **;
+    tie my $var4 => 'main', *];
     $dummy  = *$var4        ; check_count '*{}';
 }
 
@@ -202,9 +220,122 @@ $dummy  = &$var5        ; check_count '&{}';
     defined $$var7          ; check_count 'symbolic defined ${}';
 }
 
+# Constructors
+$dummy  = {$var,$var}   ; check_count '{}', 2;
+$dummy  = [$var]        ; check_count '[]';
+
 tie my $var8 => 'main', 'main';
 sub bolgy {}
 $var8->bolgy            ; check_count '->method';
+{
+    no warnings 'once';
+    () = *swibble;
+    # This must be the name of an existing glob to trigger the maximum
+    # number of fetches in 5.14:
+    tie my $var9 => 'main', 'swibble';
+    no strict 'refs';
+    use constant glumscrin => 'shreggleboughet';
+    *$var9 = \&{"glumscrin"}; check_count '*$tied = \&{"name of const"}';
+}
+
+# Functions that operate on filenames or filehandles
+for ([chdir=>''],[chmod=>'0,'],[chown=>'0,0,'],[utime=>'0,0,'],
+     [truncate=>'',',0'],[stat=>''],[lstat=>''],[open=>'my $fh,"<&",'],
+     ['()=sort'=>'',' 1,2,3']) {
+    my($op,$args,$postargs) = @$_; $postargs //= '';
+    # This line makes $var8 hold a glob:
+    $var8 = *dummy; $dummy = $var8; $count = 0;
+    eval "$op $args \$var8 $postargs";
+    check_count "$op $args\$tied_glob$postargs";
+    $var8 = *dummy; $dummy = $var8; $count = 0;
+    my $ref = \$var8;
+    eval "$op $args \$ref $postargs";
+    check_count "$op $args\\\$tied_glob$postargs";
+}
+
+SKIP:
+{
+    skip "No Config", 4 unless $can_config;
+    skip "No crypt()", 4 unless $Config::Config{d_crypt};
+    $dummy  =   crypt $var,0; check_count 'crypt $tied, ...';
+    $dummy  =   crypt 0,$var; check_count 'crypt ..., $tied';
+    $var = substr(chr 256,0,0);
+    $dummy  =   crypt $var,0; check_count 'crypt $tied_utf8, ...';
+    $var = substr(chr 256,0,0);
+    $dummy  =   crypt 0,$var; check_count 'crypt ..., $tied_utf8';
+}
+
+SKIP:
+{
+    skip "select not implemented on Win32 miniperl", 3
+        if $^O eq "MSWin32" and is_miniperl;
+    no warnings;
+    $var = *foo;
+    $dummy  =  select $var, undef, undef, 0
+                            ; check_count 'select $tied_glob, ...';
+    $var = \1;
+    $dummy  =  select $var, undef, undef, 0
+                            ; check_count 'select $tied_ref, ...';
+    $var = undef;
+    $dummy  =  select $var, undef, undef, 0
+                            ; check_count 'select $tied_undef, ...';
+}
+
+chop(my $u = "\xff\x{100}");
+tie $var, "main", $u;
+$dummy  = pack "u", $var; check_count 'pack "u", $utf8';
+$var = 0;
+$dummy  = pack "w", $var; check_count 'pack "w", $tied_int';
+$var = "111111111111111111111111111111111111111111111111111111111111111";
+$dummy  = eval { pack "w", $var };
+                          check_count 'pack "w", $tied_huge_int_as_str';
+
+tie $var, "main", "\x{100}";
+pos$var = 0             ; check_count 'lvalue pos $utf8';
+$dummy=sprintf"%1s",$var; check_count 'sprintf "%1s", $utf8';
+$dummy=sprintf"%.1s",$var; check_count 'sprintf "%.1s", $utf8';
+
+my @fmt = qw(B b c D d i O o u U X x);
+
+tie $var, "main", 23;
+for (@fmt) {
+    $dummy=sprintf"%$_",$var; check_count "sprintf '%$_'"
+}
+SKIP: {
+unless ($can_config) {
+    skip "no Config (no infinity for sprintf @fmt)", scalar @fmt;
+}
+unless ($Config::Config{d_double_has_inf}) {
+    skip "no infinity for sprintf @fmt", scalar @fmt;
+}
+tie $var, "main", "Inf";
+for (@fmt) {
+    $dummy = eval { sprintf "%$_", $var };
+                              check_count "sprintf '%$_', \$tied_inf"
+}
+}
+
+tie $var, "main", "\x{100}";
+$dummy  = substr$var,0,1; check_count 'substr $utf8';
+my $l   =\substr$var,0,1;
+$dummy  = $$l           ; check_count 'reading lvalue substr($utf8)';
+$$l     = 0             ; check_count 'setting lvalue substr($utf8)';
+tie $var, "main", "a";
+$$l     = "\x{100}"     ; check_count 'assigning $utf8 to lvalue substr';
+tie $var1, "main", "a";
+substr$var1,0,0,"\x{100}"; check_count '4-arg substr with utf8 replacement';
+
+{
+    local $SIG{__WARN__} = sub {};
+    $dummy  =  warn $var    ; check_count 'warn $tied';
+    tie $@, => 'main', 1;
+    $dummy  =  warn         ; check_count 'warn() with $@ tied (num)';
+    tie $@, => 'main', \1;
+    $dummy  =  warn         ; check_count 'warn() with $@ tied (ref)';
+    tie $@, => 'main', "foo\n";
+    $dummy  =  warn         ; check_count 'warn() with $@ tied (str)';
+    untie $@;
+}
 
 ###############################################
 #        Tests for  $foo binop $foo           #
Unnamed repository; edit this file 'description' to name the repository.