This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Make filetest ops handle get-magic correctly for glob(ref)s
[perl5.git] / t / op / tie_fetch_count.t
1 #!./perl
2 # Tests counting number of FETCHes.
3 #
4 # See Bugs #76814 and #87708.
5
6 BEGIN {
7     chdir 't' if -d 't';
8     @INC = '../lib';
9     require './test.pl';
10     plan (tests => 278);
11 }
12
13 use strict;
14 use warnings;
15
16 my $count = 0;
17
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]}}
25 sub STORE { unshift @{$_[0]}, $_[1] }
26
27
28 sub check_count {
29     my $op = shift;
30     my $expected = shift() // 1;
31     local $::Level = $::Level + 1;
32     is $count, $expected,
33         "FETCH called " . (
34           $expected == 1 ? "just once" : 
35           $expected == 2 ? "twice"     :
36                            "$count times"
37         ) . " using '$op'";
38     $count = 0;
39 }
40
41 my ($dummy, @dummy);
42
43 tie my $var => 'main', 1;
44
45 # Assignment.
46 $dummy  =  $var         ; check_count "=";
47 *dummy  =  $var         ; check_count '*glob = $tied';
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 '.';
65  
66 # Pre/post in/decrement
67            $var ++      ; check_count 'post ++';
68            $var --      ; check_count 'post --';
69         ++ $var         ; check_count 'pre ++';
70         -- $var         ; check_count 'pre --';
71
72 # Numeric comparison
73 $dummy  =  $var  <    1 ; check_count '<';
74 $dummy  =  $var  <=   1 ; check_count '<=';
75 $dummy  =  $var  ==   1 ; check_count '==';
76 $dummy  =  $var  >=   1 ; check_count '>=';
77 $dummy  =  $var  >    1 ; check_count '>';
78 $dummy  =  $var  !=   1 ; check_count '!=';
79 $dummy  =  $var <=>   1 ; check_count '<=>';
80
81 # String comparison
82 $dummy  =  $var  lt   1 ; check_count 'lt';
83 $dummy  =  $var  le   1 ; check_count 'le';
84 $dummy  =  $var  eq   1 ; check_count 'eq';
85 $dummy  =  $var  ge   1 ; check_count 'ge';
86 $dummy  =  $var  gt   1 ; check_count 'gt';
87 $dummy  =  $var  ne   1 ; check_count 'ne';
88 $dummy  =  $var cmp   1 ; check_count 'cmp';
89
90 # Bitwise operators
91 $dummy  =  $var   &   1 ; check_count '&';
92 $dummy  =  $var   ^   1 ; check_count '^';
93 $dummy  =  $var   |   1 ; check_count '|';
94 $dummy  = ~$var         ; check_count '~';
95
96 # Logical operators
97 $dummy  = !$var         ; check_count '!';
98 tie my $v_1, "main", 0;
99 $dummy  =  $v_1  ||   1 ; check_count '||';
100 $dummy  = ($v_1  or   1); check_count 'or';
101 $dummy  =  $var  &&   1 ; check_count '&&';
102 $dummy  = ($var and   1); check_count 'and';
103 $dummy  = ($var xor   1); check_count 'xor';
104 $dummy  =  $var ? 1 : 1 ; check_count '?:';
105
106 # Overloadable functions
107 $dummy  =   sin $var    ; check_count 'sin';
108 $dummy  =   cos $var    ; check_count 'cos';
109 $dummy  =   exp $var    ; check_count 'exp';
110 $dummy  =   abs $var    ; check_count 'abs';
111 $dummy  =   log $var    ; check_count 'log';
112 $dummy  =  sqrt $var    ; check_count 'sqrt';
113 $dummy  =   int $var    ; check_count 'int';
114 $dummy  = atan2 $var, 1 ; check_count 'atan2';
115
116 # Readline/glob
117 tie my $var0, "main", \*DATA;
118 $dummy  = <$var0>       ; check_count '<readline>';
119 $dummy  = <${var}>      ; check_count '<glob>';
120
121 # File operators
122 for (split //, 'rwxoRWXOezsfdpSbctugkTBMAC') {
123     no warnings 'unopened';
124     $dummy  = eval "-$_ \$var"; check_count "-$_";
125     # Make $var hold a glob:
126     $var = *dummy; $dummy = $var; $count = 0;
127     $dummy  = eval "-$_ \$var"; check_count "-$_ \$tied_glob";
128     $var = *dummy; $dummy = $var; $count = 0;
129     $dummy  = eval "-$_ \\\$var"; check_count "-$_ \\\$tied_glob";
130 }
131 $dummy  = -l $var       ; check_count '-l';
132
133 # Matching
134 $_ = "foo";
135 $dummy  =  $var =~ m/ / ; check_count 'm//';
136 $dummy  =  $var =~ s/ //; check_count 's///';
137 $dummy  =  $var ~~    1 ; check_count '~~';
138 $dummy  =  $var =~ y/ //; check_count 'y///';
139            /$var/       ; check_count 'm/pattern/';
140            /$var foo/   ; check_count 'm/$tied foo/';
141           s/$var//      ; check_count 's/pattern//';
142           s/$var foo//  ; check_count 's/$tied foo//';
143           s/./$var/     ; check_count 's//replacement/';
144
145 # Dereferencing
146 tie my $var1 => 'main', \1;
147 $dummy  = $$var1        ; check_count '${}';
148 tie my $var2 => 'main', [];
149 $dummy  = @$var2        ; check_count '@{}';
150 $dummy  = shift $var2   ; check_count 'shift arrayref';
151 tie my $var3 => 'main', {};
152 $dummy  = %$var3        ; check_count '%{}';
153 $dummy  = keys $var3    ; check_count 'keys hashref';
154 {
155     no strict 'refs';
156     tie my $var4 => 'main', **;
157     $dummy  = *$var4        ; check_count '*{}';
158 }
159
160 tie my $var5 => 'main', sub {1};
161 $dummy  = &$var5        ; check_count '&{}';
162
163 {
164     no strict 'refs';
165     tie my $var1 => 'main', 1;
166     $dummy  = $$var1        ; check_count 'symbolic ${}';
167     $dummy  = @$var1        ; check_count 'symbolic @{}';
168     $dummy  = %$var1        ; check_count 'symbolic %{}';
169     $dummy  = *$var1        ; check_count 'symbolic *{}';
170     local *1 = sub{};
171     $dummy  = &$var1        ; check_count 'symbolic &{}';
172
173     # This test will not be a complete test if *988 has been created
174     # already.  If this dies, change it to use another built-in variable.
175     # In 5.10-14, rv2gv calls get-magic more times for built-in vars, which
176     # is why we need the test this way.
177     if (exists $::{988}) {
178         die "*988 already exists. Please adjust this test"
179     }
180     tie my $var6 => main => 988;
181     no warnings;
182     readdir $var6           ; check_count 'symbolic readdir';
183     if (exists $::{973}) { # Need a different variable here
184         die "*973 already exists. Please adjust this test"
185     }
186     tie my $var7 => main => 973;
187     defined $$var7          ; check_count 'symbolic defined ${}';
188 }
189
190 tie my $var8 => 'main', 'main';
191 sub bolgy {}
192 $var8->bolgy            ; check_count '->method';
193 {
194     no warnings 'once';
195     () = *swibble;
196     # This must be the name of an existing glob to trigger the maximum
197     # number of fetches in 5.14:
198     tie my $var9 => 'main', 'swibble';
199     no strict 'refs';
200     use constant glumscrin => 'shreggleboughet';
201     *$var9 = \&{"glumscrin"}; check_count '*$tied = \&{"name of const"}';
202 }
203
204 # This line makes $var8 hold a glob:
205 $var8 = *dummy; $dummy = $var8; $count = 0;
206 eval { chdir $var8 }    ; check_count 'chdir $tied_glob';
207 $var8 = *dummy; $dummy = $var8; $count = 0;
208 eval { chdir \$var8 }    ; check_count 'chdir \$tied_glob';
209 $var8 = *dummy; $dummy = $var8; $count = 0;
210 eval { chmod 0, $var8 } ; check_count 'chmod 0,$tied_glob';
211 $var8 = *dummy; $dummy = $var8; $count = 0;
212 eval { chmod 0,\$var8 } ; check_count 'chmod 0,\$tied_glob';
213 $var8 = *dummy; $dummy = $var8; $count = 0;
214 eval { chown 0,0,$var8 }; check_count 'chown 0,0,$tied_glob';
215 $var8 = *dummy; $dummy = $var8; $count = 0;
216 eval { chown 0,0,\$var8}; check_count 'chown 0,0,\$tied_glob';
217
218
219 ###############################################
220 #        Tests for  $foo binop $foo           #
221 ###############################################
222
223 # These test that binary ops call FETCH twice if the same scalar is used
224 # for both operands. They also test that both return values from
225 # FETCH are used.
226
227 my %mutators = map { ($_ => 1) } qw(. + - * / % ** << >> & | ^);
228
229
230 sub _bin_test {
231     my $int = shift;
232     my $op = shift;
233     my $exp = pop;
234     my @fetches = @_;
235
236     $int = $int ? 'use integer; ' : '';
237
238     tie my $var, "main", @fetches;
239     is(eval "$int\$var $op \$var", $exp, "retval of $int\$var $op \$var");
240     check_count "$int$op", 2;
241
242     return unless $mutators{$op};
243
244     tie my $var2, "main", @fetches;
245     is(eval "$int \$var2 $op= \$var2", $exp, "retval of $int \$var2 $op= \$var2");
246     check_count "$int$op=", 3;
247 }
248
249 sub bin_test {
250     _bin_test(0, @_);
251 }
252
253 sub bin_int_test {
254     _bin_test(1, @_);
255 }
256
257 bin_test '**',  2, 3, 8;
258 bin_test '*' ,  2, 3, 6;
259 bin_test '/' , 10, 2, 5;
260 bin_test '%' , 11, 2, 1;
261 bin_test 'x' , 11, 2, 1111;
262 bin_test '-' , 11, 2, 9;
263 bin_test '<<', 11, 2, 44;
264 bin_test '>>', 44, 2, 11;
265 bin_test '<' ,  1, 2, 1;
266 bin_test '>' , 44, 2, 1;
267 bin_test '<=', 44, 2, "";
268 bin_test '>=',  1, 2, "";
269 bin_test '!=',  1, 2, 1;
270 bin_test '<=>', 1, 2, -1;
271 bin_test 'le',  4, 2, "";
272 bin_test 'lt',  1, 2, 1;
273 bin_test 'gt',  4, 2, 1;
274 bin_test 'ge',  1, 2, "";
275 bin_test 'eq',  1, 2, "";
276 bin_test 'ne',  1, 2, 1;
277 bin_test 'cmp', 1, 2, -1;
278 bin_test '&' ,  1, 2, 0;
279 bin_test '|' ,  1, 2, 3;
280 bin_test '^' ,  3, 5, 6;
281 bin_test '.' ,  1, 2, 12;
282 bin_test '==',  1, 2, "";
283 bin_test '+' ,  1, 2, 3;
284 bin_int_test '*' ,  2, 3, 6;
285 bin_int_test '/' , 10, 2, 5;
286 bin_int_test '%' , 11, 2, 1;
287 bin_int_test '+' ,  1, 2, 3;
288 bin_int_test '-' , 11, 2, 9;
289 bin_int_test '<' ,  1, 2, 1;
290 bin_int_test '>' , 44, 2, 1;
291 bin_int_test '<=', 44, 2, "";
292 bin_int_test '>=',  1, 2, "";
293 bin_int_test '==',  1, 2, "";
294 bin_int_test '!=',  1, 2, 1;
295 bin_int_test '<=>', 1, 2, -1;
296 tie $var, "main", 1, 4;
297 cmp_ok(atan2($var, $var), '<', .3, 'retval of atan2 $var, $var');
298 check_count 'atan2',  2;
299
300 __DATA__