This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
7cb324b1dfa930a7955baf008d8c86b524eed774
[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 => 174);
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 {1;}
26
27
28 sub check_count {
29     my $op = shift;
30     my $expected = shift() // 1;
31     is $count, $expected,
32         "FETCH called " . (
33           $expected == 1 ? "just once" : 
34           $expected == 2 ? "twice"     :
35                            "$count times"
36         ) . " using '$op'";
37     $count = 0;
38 }
39
40 my ($dummy, @dummy);
41
42 tie my $var => 'main', 1;
43
44 # Assignment.
45 $dummy  =  $var         ; check_count "=";
46
47 # Unary +/-
48 $dummy  = +$var         ; check_count "unary +";
49 $dummy  = -$var         ; check_count "unary -";
50
51 # Basic arithmetic and string operators.
52 $dummy  =  $var   +   1 ; check_count '+';
53 $dummy  =  $var   -   1 ; check_count '-';
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   x   1 ; check_count 'x';
61 @dummy  = ($var)  x   1 ; check_count 'x';
62 $dummy  =  $var   .   1 ; check_count '.';
63  
64 # Pre/post in/decrement
65            $var ++      ; check_count 'post ++';
66            $var --      ; check_count 'post --';
67         ++ $var         ; check_count 'pre ++';
68         -- $var         ; check_count 'pre --';
69
70 # Numeric comparison
71 $dummy  =  $var  <    1 ; check_count '<';
72 $dummy  =  $var  <=   1 ; check_count '<=';
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
79 # String comparison
80 $dummy  =  $var  lt   1 ; check_count 'lt';
81 $dummy  =  $var  le   1 ; check_count 'le';
82 $dummy  =  $var  eq   1 ; check_count 'eq';
83 $dummy  =  $var  ge   1 ; check_count 'ge';
84 $dummy  =  $var  gt   1 ; check_count 'gt';
85 $dummy  =  $var  ne   1 ; check_count 'ne';
86 $dummy  =  $var cmp   1 ; check_count 'cmp';
87
88 # Bitwise operators
89 $dummy  =  $var   &   1 ; check_count '&';
90 $dummy  =  $var   ^   1 ; check_count '^';
91 $dummy  =  $var   |   1 ; check_count '|';
92 $dummy  = ~$var         ; check_count '~';
93
94 # Logical operators
95 $dummy  = !$var         ; check_count '!';
96 tie my $v_1, "main", 0;
97 $dummy  =  $v_1  ||   1 ; check_count '||';
98 $dummy  = ($v_1  or   1); check_count 'or';
99 $dummy  =  $var  &&   1 ; check_count '&&';
100 $dummy  = ($var and   1); check_count 'and';
101 $dummy  = ($var xor   1); check_count 'xor';
102 $dummy  =  $var ? 1 : 1 ; check_count '?:';
103
104 # Overloadable functions
105 $dummy  =   sin $var    ; check_count 'sin';
106 $dummy  =   cos $var    ; check_count 'cos';
107 $dummy  =   exp $var    ; check_count 'exp';
108 $dummy  =   abs $var    ; check_count 'abs';
109 $dummy  =   log $var    ; check_count 'log';
110 $dummy  =  sqrt $var    ; check_count 'sqrt';
111 $dummy  =   int $var    ; check_count 'int';
112 $dummy  = atan2 $var, 1 ; check_count 'atan2';
113
114 # Readline/glob
115 tie my $var0, "main", \*DATA;
116 $dummy  = <$var0>       ; check_count '<readline>';
117 $dummy  = <${var}>      ; check_count '<glob>';
118
119 # File operators
120 $dummy  = -r $var       ; check_count '-r';
121 $dummy  = -w $var       ; check_count '-w';
122 $dummy  = -x $var       ; check_count '-x';
123 $dummy  = -o $var       ; check_count '-o';
124 $dummy  = -R $var       ; check_count '-R';
125 $dummy  = -W $var       ; check_count '-W';
126 $dummy  = -X $var       ; check_count '-X';
127 $dummy  = -O $var       ; check_count '-O';
128 $dummy  = -e $var       ; check_count '-e';
129 $dummy  = -z $var       ; check_count '-z';
130 $dummy  = -s $var       ; check_count '-s';
131 $dummy  = -f $var       ; check_count '-f';
132 $dummy  = -d $var       ; check_count '-d';
133 $dummy  = -l $var       ; check_count '-l';
134 $dummy  = -p $var       ; check_count '-p';
135 $dummy  = -S $var       ; check_count '-S';
136 $dummy  = -b $var       ; check_count '-b';
137 $dummy  = -c $var       ; check_count '-c';
138 $dummy  = -t $var       ; check_count '-t';
139 $dummy  = -u $var       ; check_count '-u';
140 $dummy  = -g $var       ; check_count '-g';
141 $dummy  = -k $var       ; check_count '-k';
142 $dummy  = -T $var       ; check_count '-T';
143 $dummy  = -B $var       ; check_count '-B';
144 $dummy  = -M $var       ; check_count '-M';
145 $dummy  = -A $var       ; check_count '-A';
146 $dummy  = -C $var       ; check_count '-C';
147
148 # Matching
149 $_ = "foo";
150 $dummy  =  $var =~ m/ / ; check_count 'm//';
151 $dummy  =  $var =~ s/ //; check_count 's///';
152 $dummy  =  $var ~~    1 ; check_count '~~';
153 $dummy  =  $var =~ y/ //; check_count 'y///';
154            /$var/       ; check_count 'm/pattern/';
155            /$var foo/   ; check_count 'm/$tied foo/';
156           s/$var//      ; check_count 's/pattern//';
157           s/$var foo//  ; check_count 's/$tied foo//';
158           s/./$var/     ; check_count 's//replacement/';
159
160 # Dereferencing
161 tie my $var1 => 'main', \1;
162 $dummy  = $$var1        ; check_count '${}';
163 tie my $var2 => 'main', [];
164 $dummy  = @$var2        ; check_count '@{}';
165 tie my $var3 => 'main', {};
166 $dummy  = %$var3        ; check_count '%{}';
167 {
168     no strict 'refs';
169     tie my $var4 => 'main', **;
170     $dummy  = *$var4        ; check_count '*{}';
171 }
172
173 tie my $var5 => 'main', sub {1};
174 $dummy  = &$var5        ; check_count '&{}';
175
176
177 ###############################################
178 #        Tests for  $foo binop $foo           #
179 ###############################################
180
181 # These test that binary ops call FETCH twice if the same scalar is used
182 # for both operands. They also test that both return values from
183 # FETCH are used.
184
185 sub bin_test {
186     my $op = shift;
187     tie my $var, "main", @_[0..$#_-1];
188     is(eval "\$var $op \$var", pop, "retval of \$var $op \$var");
189     check_count $op, 2;
190 }
191 sub bin_int_test {
192     my $op = shift;
193     tie my $var, "main", @_[0..$#_-1];
194     is(eval "use integer; \$var $op \$var", pop,
195        "retval of \$var $op \$var under use integer");
196     check_count "$op under use integer", 2;
197 }
198
199 bin_test '**',  2, 3, 8;
200 bin_test '*' ,  2, 3, 6;
201 bin_test '/' , 10, 2, 5;
202 bin_test '%' , 11, 2, 1;
203 bin_test 'x' , 11, 2, 1111;
204 bin_test '-' , 11, 2, 9;
205 bin_test '<<', 11, 2, 44;
206 bin_test '>>', 44, 2, 11;
207 bin_test '<' ,  1, 2, 1;
208 bin_test '>' , 44, 2, 1;
209 bin_test '<=', 44, 2, "";
210 bin_test '>=',  1, 2, "";
211 bin_test '!=',  1, 2, 1;
212 bin_test '<=>', 1, 2, -1;
213 bin_test 'le',  4, 2, "";
214 bin_test 'lt',  1, 2, 1;
215 bin_test 'gt',  4, 2, 1;
216 bin_test 'ge',  1, 2, "";
217 bin_test 'eq',  1, 2, "";
218 bin_test 'ne',  1, 2, 1;
219 bin_test 'cmp', 1, 2, -1;
220 bin_test '&' ,  1, 2, 0;
221 bin_test '|' ,  1, 2, 3;
222 bin_test '^' ,  3, 5, 6;
223 bin_test '.' ,  1, 2, 12;
224 bin_test '==',  1, 2, "";
225 bin_test '+' ,  1, 2, 3;
226 bin_int_test '*' ,  2, 3, 6;
227 bin_int_test '/' , 10, 2, 5;
228 bin_int_test '%' , 11, 2, 1;
229 bin_int_test '+' ,  1, 2, 3;
230 bin_int_test '-' , 11, 2, 9;
231 bin_int_test '<' ,  1, 2, 1;
232 bin_int_test '>' , 44, 2, 1;
233 bin_int_test '<=', 44, 2, "";
234 bin_int_test '>=',  1, 2, "";
235 bin_int_test '==',  1, 2, "";
236 bin_int_test '!=',  1, 2, 1;
237 bin_int_test '<=>', 1, 2, -1;
238 tie $var, "main", 1, 4;
239 cmp_ok(atan2($var, $var), '<', .3, 'retval of atan2 $var, $var');
240 check_count 'atan2',  2;
241
242 __DATA__