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

#!./perl
# Tests counting number of FETCHes.
#
# See Bugs #76814 and #87708.

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

use strict;
use warnings;

my $count = 0;

# Usage:
#   tie $var, "main", $val;          # FETCH returns $val
#   tie $var, "main", $val1, $val2;  # FETCH returns the values in order,
#                                    # one at a time, repeating the last
#                                    # when the list is exhausted.
sub TIESCALAR {my $pack = shift; bless [@_], $pack;}
sub FETCH {$count ++; @{$_ [0]} == 1 ? ${$_ [0]}[0] : shift @{$_ [0]}}
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" : 
          $expected == 2 ? "twice"     :
                           "$count times"
        ) . " using '$op'";
    $count = 0;
}

my ($dummy, @dummy);

tie my $var => 'main', 1;

# Assignment.
$dummy  =  $var         ; check_count "=";
*dummy  =  $var         ; check_count '*glob = $tied';

# Unary +/-
$dummy  = +$var         ; check_count "unary +";
$dummy  = -$var         ; check_count "unary -";

# Basic arithmetic and string operators.
$dummy  =  $var   +   1 ; check_count '+';
$dummy  =  $var   -   1 ; check_count '-';
$dummy  =  $var   /   1 ; check_count '/';
$dummy  =  $var   *   1 ; check_count '*';
$dummy  =  $var   %   1 ; check_count '%';
$dummy  =  $var  **   1 ; check_count '**';
$dummy  =  $var  <<   1 ; check_count '<<';
$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 ++';
           $var --      ; check_count 'post --';
        ++ $var         ; check_count 'pre ++';
        -- $var         ; check_count 'pre --';

# Numeric comparison
$dummy  =  $var  <    1 ; check_count '<';
$dummy  =  $var  <=   1 ; check_count '<=';
$dummy  =  $var  ==   1 ; check_count '==';
$dummy  =  $var  >=   1 ; check_count '>=';
$dummy  =  $var  >    1 ; check_count '>';
$dummy  =  $var  !=   1 ; check_count '!=';
$dummy  =  $var <=>   1 ; check_count '<=>';

# String comparison
$dummy  =  $var  lt   1 ; check_count 'lt';
$dummy  =  $var  le   1 ; check_count 'le';
$dummy  =  $var  eq   1 ; check_count 'eq';
$dummy  =  $var  ge   1 ; check_count 'ge';
$dummy  =  $var  gt   1 ; check_count 'gt';
$dummy  =  $var  ne   1 ; check_count 'ne';
$dummy  =  $var cmp   1 ; check_count 'cmp';

# Bitwise operators
$dummy  =  $var   &   1 ; check_count '&';
$dummy  =  $var   ^   1 ; check_count '^';
$dummy  =  $var   |   1 ; check_count '|';
$dummy  = ~$var         ; check_count '~';

# Logical operators
$dummy  = !$var         ; check_count '!';
tie my $v_1, "main", 0;
$dummy  =  $v_1  ||   1 ; check_count '||';
$dummy  = ($v_1  or   1); check_count 'or';
$dummy  =  $var  &&   1 ; check_count '&&';
$dummy  = ($var and   1); check_count 'and';
$dummy  = ($var xor   1); check_count 'xor';
$dummy  =  $var ? 1 : 1 ; check_count '?:';

# Overloadable functions
$dummy  =   sin $var    ; check_count 'sin';
$dummy  =   cos $var    ; check_count 'cos';
$dummy  =   exp $var    ; check_count 'exp';
$dummy  =   abs $var    ; check_count 'abs';
$dummy  =   log $var    ; check_count 'log';
$dummy  =  sqrt $var    ; check_count 'sqrt';
$dummy  =   int $var    ; check_count 'int';
$dummy  = atan2 $var, 1 ; check_count 'atan2';

# Readline/glob
tie my $var0, "main", \*DATA;
$dummy  = <$var0>       ; check_count '<readline>';
$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
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';
$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///';
{
    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//';
          s/$var foo//  ; check_count 's/$tied foo//';
          s/./$var/     ; check_count 's//replacement/';

# Dereferencing
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', *];
    $dummy  = *$var4        ; check_count '*{}';
}

tie my $var5 => 'main', sub {1};
$dummy  = &$var5        ; check_count '&{}';

{
    no strict 'refs';
    tie my $var1 => 'main', 1;
    $dummy  = $$var1        ; check_count 'symbolic ${}';
    $dummy  = @$var1        ; check_count 'symbolic @{}';
    $dummy  = %$var1        ; check_count 'symbolic %{}';
    $dummy  = *$var1        ; check_count 'symbolic *{}';
    local *1 = sub{};
    $dummy  = &$var1        ; check_count 'symbolic &{}';

    # This test will not be a complete test if *988 has been created
    # already.  If this dies, change it to use another built-in variable.
    # In 5.10-14, rv2gv calls get-magic more times for built-in vars, which
    # is why we need the test this way.
    if (exists $::{988}) {
	die "*988 already exists. Please adjust this test"
    }
    tie my $var6 => main => 988;
    no warnings;
    readdir $var6           ; check_count 'symbolic readdir';
    if (exists $::{973}) { # Need a different variable here
	die "*973 already exists. Please adjust this test"
    }
    tie my $var7 => main => 973;
    defined $$var7          ; check_count 'symbolic defined ${}';
}

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";
}

{
    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';

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';
$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           #
###############################################

# These test that binary ops call FETCH twice if the same scalar is used
# for both operands. They also test that both return values from
# FETCH are used.

my %mutators = map { ($_ => 1) } qw(. + - * / % ** << >> & | ^);


sub _bin_test {
    my $int = shift;
    my $op = shift;
    my $exp = pop;
    my @fetches = @_;

    $int = $int ? 'use integer; ' : '';

    tie my $var, "main", @fetches;
    is(eval "$int\$var $op \$var", $exp, "retval of $int\$var $op \$var");
    check_count "$int$op", 2;

    return unless $mutators{$op};

    tie my $var2, "main", @fetches;
    is(eval "$int \$var2 $op= \$var2", $exp, "retval of $int \$var2 $op= \$var2");
    check_count "$int$op=", 3;
}

sub bin_test {
    _bin_test(0, @_);
}

sub bin_int_test {
    _bin_test(1, @_);
}

bin_test '**',  2, 3, 8;
bin_test '*' ,  2, 3, 6;
bin_test '/' , 10, 2, 5;
bin_test '%' , 11, 2, 1;
bin_test 'x' , 11, 2, 1111;
bin_test '-' , 11, 2, 9;
bin_test '<<', 11, 2, 44;
bin_test '>>', 44, 2, 11;
bin_test '<' ,  1, 2, 1;
bin_test '>' , 44, 2, 1;
bin_test '<=', 44, 2, "";
bin_test '>=',  1, 2, "";
bin_test '!=',  1, 2, 1;
bin_test '<=>', 1, 2, -1;
bin_test 'le',  4, 2, "";
bin_test 'lt',  1, 2, 1;
bin_test 'gt',  4, 2, 1;
bin_test 'ge',  1, 2, "";
bin_test 'eq',  1, 2, "";
bin_test 'ne',  1, 2, 1;
bin_test 'cmp', 1, 2, -1;
bin_test '&' ,  1, 2, 0;
bin_test '|' ,  1, 2, 3;
bin_test '^' ,  3, 5, 6;
bin_test '.' ,  1, 2, 12;
bin_test '==',  1, 2, "";
bin_test '+' ,  1, 2, 3;
bin_int_test '*' ,  2, 3, 6;
bin_int_test '/' , 10, 2, 5;
bin_int_test '%' , 11, 2, 1;
bin_int_test '+' ,  1, 2, 3;
bin_int_test '-' , 11, 2, 9;
bin_int_test '<' ,  1, 2, 1;
bin_int_test '>' , 44, 2, 1;
bin_int_test '<=', 44, 2, "";
bin_int_test '>=',  1, 2, "";
bin_int_test '==',  1, 2, "";
bin_int_test '!=',  1, 2, 1;
bin_int_test '<=>', 1, 2, -1;
tie $var, "main", 1, 4;
cmp_ok(atan2($var, $var), '<', .3, 'retval of atan2 $var, $var');
check_count 'atan2',  2;

__DATA__
Commit	Line	Data
60ccc62f A	1	#!./perl
	2	# Tests counting number of FETCHes.
	3	#
b04496fe	4	# See Bugs #76814 and #87708.
60ccc62f A	5
	6	BEGIN {
	7	chdir 't' if -d 't';
	8	@INC = '../lib';
	9	require './test.pl';
01680ee9	10	plan (tests => 312);
60ccc62f A	11	}
	12
	13	use strict;
	14	use warnings;
	15
60ccc62f A	16	my $count = 0;
60ccc62f A	17
b04496fe FC	18	# Usage:
	19	# tie $var, "main", $val; # FETCH returns $val
	20	# tie $var, "main", $val1, $val2; # FETCH returns the values in order,
	21	# # one at a time, repeating the last
	22	# # when the list is exhausted.
	23	sub TIESCALAR {my $pack = shift; bless [@_], $pack;}
	24	sub FETCH {$count ++; @{$_ [0]} == 1 ? ${$_ [0]}[0] : shift @{$_ [0]}}
9c9a2500	25	sub STORE { unshift @{$_[0]}, $_[1] }
60ccc62f A	26
	27
	28	sub check_count {
	29	my $op = shift;
b04496fe	30	my $expected = shift() // 1;
5e0b4493	31	local $::Level = $::Level + 1;
b04496fe FC	32	is $count, $expected,
	33	"FETCH called " . (
	34	$expected == 1 ? "just once" :
	35	$expected == 2 ? "twice" :
	36	"$count times"
	37	) . " using '$op'";
60ccc62f A	38	$count = 0;
	39	}
	40
	41	my ($dummy, @dummy);
	42
	43	tie my $var => 'main', 1;
	44
	45	# Assignment.
	46	$dummy = $var ; check_count "=";
93564729	47	dummy = $var ; check_count 'glob = $tied';
60ccc62f A	48
	49	# Unary +/-
	50	$dummy = +$var ; check_count "unary +";
	51	$dummy = -$var ; check_count "unary -";
	52
	53	# Basic arithmetic and string operators.
	54	$dummy = $var + 1 ; check_count '+';
	55	$dummy = $var - 1 ; check_count '-';
	56	$dummy = $var / 1 ; check_count '/';
	57	$dummy = $var * 1 ; check_count '*';
	58	$dummy = $var % 1 ; check_count '%';
	59	$dummy = $var 1 ; check_count '';
	60	$dummy = $var << 1 ; check_count '<<';
	61	$dummy = $var >> 1 ; check_count '>>';
	62	$dummy = $var x 1 ; check_count 'x';
	63	@dummy = ($var) x 1 ; check_count 'x';
	64	$dummy = $var . 1 ; check_count '.';
f52e41ad FC	65	@dummy = $var .. 1 ; check_count '$tied..1';
	66	@dummy = 1 .. $var; check_count '1..$tied';
	67	tie my $v42 => 'main', "z";
	68	@dummy = $v42 .. "a"; check_count '$tied.."a"';
	69	@dummy = "a" .. $v42; check_count '"a"..$tied';
60ccc62f A	70
	71	# Pre/post in/decrement
	72	$var ++ ; check_count 'post ++';
	73	$var -- ; check_count 'post --';
	74	++ $var ; check_count 'pre ++';
	75	-- $var ; check_count 'pre --';
	76
	77	# Numeric comparison
	78	$dummy = $var < 1 ; check_count '<';
	79	$dummy = $var <= 1 ; check_count '<=';
	80	$dummy = $var == 1 ; check_count '==';
	81	$dummy = $var >= 1 ; check_count '>=';
	82	$dummy = $var > 1 ; check_count '>';
	83	$dummy = $var != 1 ; check_count '!=';
	84	$dummy = $var <=> 1 ; check_count '<=>';
	85
	86	# String comparison
078504b2 FC	87	$dummy = $var lt 1 ; check_count 'lt';
	88	$dummy = $var le 1 ; check_count 'le';
	89	$dummy = $var eq 1 ; check_count 'eq';
	90	$dummy = $var ge 1 ; check_count 'ge';
	91	$dummy = $var gt 1 ; check_count 'gt';
	92	$dummy = $var ne 1 ; check_count 'ne';
	93	$dummy = $var cmp 1 ; check_count 'cmp';
60ccc62f A	94
	95	# Bitwise operators
	96	$dummy = $var & 1 ; check_count '&';
	97	$dummy = $var ^ 1 ; check_count '^';
	98	$dummy = $var \| 1 ; check_count '\|';
	99	$dummy = ~$var ; check_count '~';
	100
	101	# Logical operators
06c841cf	102	$dummy = !$var ; check_count '!';
1c3caf3f FC	103	tie my $v_1, "main", 0;
	104	$dummy = $v_1 \|\| 1 ; check_count '\|\|';
	105	$dummy = ($v_1 or 1); check_count 'or';
60ccc62f A	106	$dummy = $var && 1 ; check_count '&&';
	107	$dummy = ($var and 1); check_count 'and';
	108	$dummy = ($var xor 1); check_count 'xor';
	109	$dummy = $var ? 1 : 1 ; check_count '?:';
	110
	111	# Overloadable functions
	112	$dummy = sin $var ; check_count 'sin';
	113	$dummy = cos $var ; check_count 'cos';
	114	$dummy = exp $var ; check_count 'exp';
	115	$dummy = abs $var ; check_count 'abs';
	116	$dummy = log $var ; check_count 'log';
	117	$dummy = sqrt $var ; check_count 'sqrt';
	118	$dummy = int $var ; check_count 'int';
	119	$dummy = atan2 $var, 1 ; check_count 'atan2';
	120
	121	# Readline/glob
	122	tie my $var0, "main", \*DATA;
	123	$dummy = <$var0> ; check_count '<readline>';
5668452f FC	124	$var = \1;
	125	$var .= <DATA> ; check_count '$tiedref .= <rcatline>';
	126	$var = "tied";
	127	$var .= <DATA> ; check_count '$tiedstr .= <rcatline>';
	128	$var = *foo;
	129	$var .= <DATA> ; check_count '$tiedglob .= <rcatline>';
d03ce4f5 FC	130	{ no warnings "glob";
	131	$dummy = <${var}> ; check_count '<glob>';
	132	}
60ccc62f A	133
60ccc62f A	134	# File operators
094a3eec FC	135	for (split //, 'rwxoRWXOezsfdpSbctugkTBMAC') {
	136	no warnings 'unopened';
	137	$dummy = eval "-$_ \$var"; check_count "-$_";
	138	# Make $var hold a glob:
	139	$var = *dummy; $dummy = $var; $count = 0;
	140	$dummy = eval "-$_ \$var"; check_count "-$_ \$tied_glob";
026624ed	141	next if /[guk]/;
094a3eec	142	$var = *dummy; $dummy = $var; $count = 0;
026624ed FC	143	eval "\$dummy = -$_ \\\$var";
026624ed FC	144	check_count "-$_ \\\$tied_glob";
094a3eec	145	}
60ccc62f	146	$dummy = -l $var ; check_count '-l';
c5780028 FC	147	$var = "test.pl";
c5780028 FC	148	$dummy = -e -e -e $var ; check_count '-e -e';
60ccc62f A	149
	150	# Matching
	151	$_ = "foo";
	152	$dummy = $var =~ m/ / ; check_count 'm//';
	153	$dummy = $var =~ s/ //; check_count 's///';
0f539b13 BF	154	{
	155	no warnings 'experimental::smartmatch';
	156	$dummy = $var ~~ 1 ; check_count '~~';
	157	}
9138d6ca	158	$dummy = $var =~ y/ //; check_count 'y///';
b4cc4d79 FC	159	$var = \1;
b4cc4d79 FC	160	$dummy = $var =~y/ /-/; check_count '$ref =~ y///';
a9984b10 FC	161	/$var/ ; check_count 'm/pattern/';
	162	/$var foo/ ; check_count 'm/$tied foo/';
	163	s/$var// ; check_count 's/pattern//';
	164	s/$var foo// ; check_count 's/$tied foo//';
60ccc62f A	165	s/./$var/ ; check_count 's//replacement/';
	166
	167	# Dereferencing
	168	tie my $var1 => 'main', \1;
	169	$dummy = $$var1 ; check_count '${}';
	170	tie my $var2 => 'main', [];
	171	$dummy = @$var2 ; check_count '@{}';
d2d95e13	172	$dummy = shift $var2 ; check_count 'shift arrayref';
60ccc62f A	173	tie my $var3 => 'main', {};
60ccc62f A	174	$dummy = %$var3 ; check_count '%{}';
075980ed	175	$dummy = keys $var3 ; check_count 'keys hashref';
60ccc62f A	176	{
60ccc62f A	177	no strict 'refs';
05c5ed48	178	tie my $var4 => 'main', *];
60ccc62f A	179	$dummy = $var4 ; check_count '{}';
	180	}
	181
	182	tie my $var5 => 'main', sub {1};
	183	$dummy = &$var5 ; check_count '&{}';
	184
7ffa7e75 FC	185	{
	186	no strict 'refs';
	187	tie my $var1 => 'main', 1;
	188	$dummy = $$var1 ; check_count 'symbolic ${}';
	189	$dummy = @$var1 ; check_count 'symbolic @{}';
	190	$dummy = %$var1 ; check_count 'symbolic %{}';
	191	$dummy = $var1 ; check_count 'symbolic {}';
	192	local *1 = sub{};
	193	$dummy = &$var1 ; check_count 'symbolic &{}';
ed996e63	194
c00274d3	195	# This test will not be a complete test if *988 has been created
ed996e63 FC	196	# already. If this dies, change it to use another built-in variable.
	197	# In 5.10-14, rv2gv calls get-magic more times for built-in vars, which
	198	# is why we need the test this way.
c00274d3 FC	199	if (exists $::{988}) {
c00274d3 FC	200	die "*988 already exists. Please adjust this test"
ed996e63	201	}
c00274d3	202	tie my $var6 => main => 988;
ed996e63 FC	203	no warnings;
ed996e63 FC	204	readdir $var6 ; check_count 'symbolic readdir';
ad6acfc4 FC	205	if (exists $::{973}) { # Need a different variable here
	206	die "*973 already exists. Please adjust this test"
	207	}
	208	tie my $var7 => main => 973;
	209	defined $$var7 ; check_count 'symbolic defined ${}';
7ffa7e75	210	}
b04496fe	211
da6b625f FC	212	tie my $var8 => 'main', 'main';
	213	sub bolgy {}
	214	$var8->bolgy ; check_count '->method';
33d4ef81	215	{
f8ccc5c6	216	no warnings 'once';
33d4ef81 FC	217	() = *swibble;
	218	# This must be the name of an existing glob to trigger the maximum
	219	# number of fetches in 5.14:
	220	tie my $var9 => 'main', 'swibble';
	221	no strict 'refs';
	222	use constant glumscrin => 'shreggleboughet';
	223	$var9 = \&{"glumscrin"}; check_count '$tied = \&{"name of const"}';
	224	}
da6b625f	225
d06f995a	226	# Functions that operate on filenames or filehandles
5e0adc2d	227	for ([chdir=>''],[chmod=>'0,'],[chown=>'0,0,'],[utime=>'0,0,'],
8d9d90d5 FC	228	[truncate=>'',',0'],[stat=>''],[lstat=>''],[open=>'my $fh,"<&",'],
8d9d90d5 FC	229	['()=sort'=>'',' 1,2,3']) {
5e0adc2d	230	my($op,$args,$postargs) = @$_; $postargs //= '';
d06f995a FC	231	# This line makes $var8 hold a glob:
d06f995a FC	232	$var8 = *dummy; $dummy = $var8; $count = 0;
5e0adc2d FC	233	eval "$op $args \$var8 $postargs";
5e0adc2d FC	234	check_count "$op $args\$tied_glob$postargs";
d06f995a	235	$var8 = *dummy; $dummy = $var8; $count = 0;
8d9d90d5 FC	236	my $ref = \$var8;
8d9d90d5 FC	237	eval "$op $args \$ref $postargs";
5e0adc2d	238	check_count "$op $args\\\$tied_glob$postargs";
d06f995a	239	}
93564729	240
9d6d5a79 FC	241	{
	242	no warnings;
	243	$var = *foo;
	244	$dummy = select $var, undef, undef, 0
	245	; check_count 'select $tied_glob, ...';
	246	$var = \1;
	247	$dummy = select $var, undef, undef, 0
	248	; check_count 'select $tied_ref, ...';
	249	$var = undef;
	250	$dummy = select $var, undef, undef, 0
	251	; check_count 'select $tied_undef, ...';
	252	}
	253
3f63b0e5 FC	254	chop(my $u = "\xff\x{100}");
	255	tie $var, "main", $u;
	256	$dummy = pack "u", $var; check_count 'pack "u", $utf8';
	257
92cf6698 FC	258	tie $var, "main", "\x{100}";
92cf6698 FC	259	pos$var = 0 ; check_count 'lvalue pos $utf8';
4b8b6103	260	$dummy=sprintf"%1s",$var; check_count 'sprintf "%1s", $utf8';
d8f2f090	261	$dummy=sprintf"%.1s",$var; check_count 'sprintf "%.1s", $utf8';
864329c3	262	$dummy = substr$var,0,1; check_count 'substr $utf8';
a4036ec1 FC	263	my $l =\substr$var,0,1;
a4036ec1 FC	264	$dummy = $$l ; check_count 'reading lvalue substr($utf8)';
ab445a17	265	$$l = 0 ; check_count 'setting lvalue substr($utf8)';
73a087f0 FC	266	tie $var, "main", "a";
73a087f0 FC	267	$$l = "\x{100}" ; check_count 'assigning $utf8 to lvalue substr';
01680ee9 FC	268	tie $var1, "main", "a";
01680ee9 FC	269	substr$var1,0,0,"\x{100}"; check_count '4-arg substr with utf8 replacement';
864329c3	270
ef5fe392 FC	271	{
	272	local $SIG{__WARN__} = sub {};
	273	$dummy = warn $var ; check_count 'warn $tied';
	274	tie $@, => 'main', 1;
	275	$dummy = warn ; check_count 'warn() with $@ tied (num)';
	276	tie $@, => 'main', \1;
	277	$dummy = warn ; check_count 'warn() with $@ tied (ref)';
	278	tie $@, => 'main', "foo\n";
	279	$dummy = warn ; check_count 'warn() with $@ tied (str)';
	280	untie $@;
	281	}
	282
b04496fe FC	283	###############################################
	284	# Tests for $foo binop $foo #
	285	###############################################
	286
	287	# These test that binary ops call FETCH twice if the same scalar is used
	288	# for both operands. They also test that both return values from
	289	# FETCH are used.
	290
9c9a2500 DM	291	my %mutators = map { ($_ => 1) } qw(. + - * / % ** << >> & \| ^);
	292
	293
	294	sub _bin_test {
	295	my $int = shift;
b04496fe	296	my $op = shift;
9c9a2500 DM	297	my $exp = pop;
	298	my @fetches = @_;
	299
	300	$int = $int ? 'use integer; ' : '';
	301
	302	tie my $var, "main", @fetches;
	303	is(eval "$int\$var $op \$var", $exp, "retval of $int\$var $op \$var");
	304	check_count "$int$op", 2;
	305
	306	return unless $mutators{$op};
	307
	308	tie my $var2, "main", @fetches;
	309	is(eval "$int \$var2 $op= \$var2", $exp, "retval of $int \$var2 $op= \$var2");
	310	check_count "$int$op=", 3;
	311	}
	312
	313	sub bin_test {
	314	_bin_test(0, @_);
b04496fe	315	}
9c9a2500	316
b04496fe	317	sub bin_int_test {
9c9a2500	318	_bin_test(1, @_);
b04496fe FC	319	}
b04496fe FC	320
75ea7a12 FC	321	bin_test '**', 2, 3, 8;
	322	bin_test '*' , 2, 3, 6;
	323	bin_test '/' , 10, 2, 5;
	324	bin_test '%' , 11, 2, 1;
	325	bin_test 'x' , 11, 2, 1111;
	326	bin_test '-' , 11, 2, 9;
	327	bin_test '<<', 11, 2, 44;
	328	bin_test '>>', 44, 2, 11;
	329	bin_test '<' , 1, 2, 1;
	330	bin_test '>' , 44, 2, 1;
	331	bin_test '<=', 44, 2, "";
	332	bin_test '>=', 1, 2, "";
	333	bin_test '!=', 1, 2, 1;
	334	bin_test '<=>', 1, 2, -1;
	335	bin_test 'le', 4, 2, "";
	336	bin_test 'lt', 1, 2, 1;
	337	bin_test 'gt', 4, 2, 1;
	338	bin_test 'ge', 1, 2, "";
	339	bin_test 'eq', 1, 2, "";
	340	bin_test 'ne', 1, 2, 1;
	341	bin_test 'cmp', 1, 2, -1;
	342	bin_test '&' , 1, 2, 0;
	343	bin_test '\|' , 1, 2, 3;
3216d309	344	bin_test '^' , 3, 5, 6;
b04496fe	345	bin_test '.' , 1, 2, 12;
7d779b23	346	bin_test '==', 1, 2, "";
4c3ac4ba	347	bin_test '+' , 1, 2, 3;
96b6b87f	348	bin_int_test '*' , 2, 3, 6;
76422f81	349	bin_int_test '/' , 10, 2, 5;
96b6b87f	350	bin_int_test '%' , 11, 2, 1;
e62ca0f9 FC	351	bin_int_test '+' , 1, 2, 3;
e62ca0f9 FC	352	bin_int_test '-' , 11, 2, 9;
9b029393	353	bin_int_test '<' , 1, 2, 1;
fd2dbd2b	354	bin_int_test '>' , 44, 2, 1;
5c7d20ff	355	bin_int_test '<=', 44, 2, "";
f2bd3a8b	356	bin_int_test '>=', 1, 2, "";
bfa9dccd	357	bin_int_test '==', 1, 2, "";
577914ca	358	bin_int_test '!=', 1, 2, 1;
4cdd48d8	359	bin_int_test '<=>', 1, 2, -1;
c31c2913 FC	360	tie $var, "main", 1, 4;
	361	cmp_ok(atan2($var, $var), '<', .3, 'retval of atan2 $var, $var');
	362	check_count 'atan2', 2;
b04496fe	363
60ccc62f	364	__DATA__