Stop "\N{...}" from leaking after errors
[perl.git] / t / op / svleak.t
1 #!./perl
2
3 # A place to put some simple leak tests. Uses XS::APItest to make
4 # PL_sv_count available, allowing us to run a bit of code multiple times and
5 # see if the count increases.
6
7 BEGIN {
8     chdir 't';
9     @INC = '../lib';
10     require './test.pl';
11
12     eval { require XS::APItest; XS::APItest->import('sv_count'); 1 }
13         or skip_all("XS::APItest not available");
14 }
15
16 use Config;
17
18 plan tests => 108;
19
20 # run some code N times. If the number of SVs at the end of loop N is
21 # greater than (N-1)*delta at the end of loop 1, we've got a leak
22 #
23 sub leak {
24     my ($n, $delta, $code, @rest) = @_;
25     my $sv0 = 0;
26     my $sv1 = 0;
27     for my $i (1..$n) {
28         &$code();
29         $sv1 = sv_count();
30         $sv0 = $sv1 if $i == 1;
31     }
32     cmp_ok($sv1-$sv0, '<=', ($n-1)*$delta, @rest);
33 }
34
35 # Like leak, but run a string eval instead.
36 # The code is used instead of the test name
37 # if the name is absent.
38 sub eleak {
39     my ($n,$delta,$code,@rest) = @_;
40     leak $n, $delta, sub { eval $code },
41          @rest ? @rest : $code
42 }
43
44 # run some expression N times. The expr is concatenated N times and then
45 # evaled, ensuring that that there are no scope exits between executions.
46 # If the number of SVs at the end of expr N is greater than (N-1)*delta at
47 # the end of expr 1, we've got a leak
48 #
49 sub leak_expr {
50     my ($n, $delta, $expr, @rest) = @_;
51     my $sv0 = 0;
52     my $sv1 = 0;
53     my $true = 1; # avoid stuff being optimised away
54     my $code1 = "($expr || \$true)";
55     my $code = "$code1 && (\$sv0 = sv_count())" . ("&& $code1" x 4)
56                 . " && (\$sv1 = sv_count())";
57     if (eval $code) {
58         cmp_ok($sv1-$sv0, '<=', ($n-1)*$delta, @rest);
59     }
60     else {
61         fail("eval @rest: $@");
62     }
63 }
64
65
66 my @a;
67
68 leak(5, 0, sub {},                 "basic check 1 of leak test infrastructure");
69 leak(5, 0, sub {push @a,1;pop @a}, "basic check 2 of leak test infrastructure");
70 leak(5, 1, sub {push @a,1;},       "basic check 3 of leak test infrastructure");
71
72 # Fatal warnings
73 my $f = "use warnings FATAL =>";
74 my $all = "$f 'all';";
75 eleak(2, 0, "$f 'deprecated'; qq|\\c\{|", 'qq|\c{| with fatal warnings');
76 eleak(2, 0, "$f 'syntax'; qq|\\c`|", 'qq|\c`| with fatal warnings');
77 eleak(2, 0, "$all /\$\\ /", '/$\ / with fatal warnings');
78 eleak(2, 0, "$all s//\\1/", 's//\1/ with fatal warnings');
79 eleak(2, 0, "$all qq|\\i|", 'qq|\i| with fatal warnings');
80 eleak(2, 0, "$f 'digit'; qq|\\o{9}|", 'qq|\o{9}| with fatal warnings');
81 eleak(2, 0, "$f 'misc'; sub foo{} sub foo:lvalue",
82      'ignored :lvalue with fatal warnings');
83 eleak(2, 0, "no warnings; use feature ':all'; $f 'misc';
84              my sub foo{} sub foo:lvalue",
85      'ignored mysub :lvalue with fatal warnings');
86 eleak(2, 0, "no warnings; use feature ':all'; $all
87              my sub foo{} sub foo:lvalue{}",
88      'fatal mysub redef warning');
89 eleak(2, 0, "$all sub foo{} sub foo{}", 'fatal sub redef warning');
90 eleak(2, 0, "$all *x=sub {}",
91      'fatal sub redef warning with sub-to-glob assignment');
92 eleak(2, 0, "$all *x=sub() {1}",
93      'fatal const sub redef warning with sub-to-glob assignment');
94 eleak(2, 0, "$all XS::APItest::newCONSTSUB(\\%main::=>name=>0=>1)",
95      'newCONSTSUB sub redefinition with fatal warnings');
96 eleak(2, 0, "$f 'misc'; my\$a,my\$a", 'double my with fatal warnings');
97 eleak(2, 0, "$f 'misc'; our\$a,our\$a", 'double our with fatal warnings');
98 eleak(2, 0, "$f 'closure';
99              sub foo { my \$x; format=\n\@\n\$x\n.\n} write; ",
100      'format closing over unavailable var with fatal warnings');
101 eleak(2, 0, "$all /(?{})?/ ", '(?{})? with fatal warnings');
102 eleak(2, 0, "$all /(?{})+/ ", '(?{})+ with fatal warnings');
103 eleak(2, 0, "$all /[\\i]/ ", 'invalid charclass escape with fatal warns');
104 eleak(2, 0, "$all /[:foo:]/ ", '/[:foo:]/ with fatal warnings');
105 eleak(2, 0, "$all /[a-\\d]/ ", '[a-\d] char class with fatal warnings');
106 eleak(2, 0, "$all v111111111111111111111111111111111111111111111111",
107      'vstring num overflow with fatal warnings');
108
109 eleak(2, 0, 'sub{<*>}');
110
111 eleak(2, 0, 'goto sub {}', 'goto &sub in eval');
112 eleak(2, 0, '() = sort { goto sub {} } 1,2', 'goto &sub in sort');
113 eleak(2, 0, '/(?{ goto sub {} })/', 'goto &sub in regexp');
114
115 sub TIEARRAY    { bless [], $_[0] }
116 sub FETCH       { $_[0]->[$_[1]] }
117 sub STORE       { $_[0]->[$_[1]] = $_[2] }
118
119 # local $tied_elem[..] leaks <20020502143736.N16831@dansat.data-plan.com>"
120 {
121     tie my @a, 'main';
122     leak(5, 0, sub {local $a[0]}, "local \$tied[0]");
123 }
124
125 # [perl #74484]  repeated tries leaked SVs on the tmps stack
126
127 leak_expr(5, 0, q{"YYYYYa" =~ /.+?(a(.+?)|b)/ }, "trie leak");
128
129 # [perl #48004] map/grep didn't free tmps till the end
130
131 {
132     # qr/1/ just creates tmps that are hopefully freed per iteration
133
134     my $s;
135     my @a;
136     my @count = (0) x 4; # pre-allocate
137
138     grep qr/1/ && ($count[$_] = sv_count()) && 99,  0..3;
139     is(@count[3] - @count[0], 0, "void   grep expr:  no new tmps per iter");
140     grep { qr/1/ && ($count[$_] = sv_count()) && 99 }  0..3;
141     is(@count[3] - @count[0], 0, "void   grep block: no new tmps per iter");
142
143     $s = grep qr/1/ && ($count[$_] = sv_count()) && 99,  0..3;
144     is(@count[3] - @count[0], 0, "scalar grep expr:  no new tmps per iter");
145     $s = grep { qr/1/ && ($count[$_] = sv_count()) && 99 }  0..3;
146     is(@count[3] - @count[0], 0, "scalar grep block: no new tmps per iter");
147
148     @a = grep qr/1/ && ($count[$_] = sv_count()) && 99,  0..3;
149     is(@count[3] - @count[0], 0, "list   grep expr:  no new tmps per iter");
150     @a = grep { qr/1/ && ($count[$_] = sv_count()) && 99 }  0..3;
151     is(@count[3] - @count[0], 0, "list   grep block: no new tmps per iter");
152
153
154     map qr/1/ && ($count[$_] = sv_count()) && 99,  0..3;
155     is(@count[3] - @count[0], 0, "void   map expr:  no new tmps per iter");
156     map { qr/1/ && ($count[$_] = sv_count()) && 99 }  0..3;
157     is(@count[3] - @count[0], 0, "void   map block: no new tmps per iter");
158
159     $s = map qr/1/ && ($count[$_] = sv_count()) && 99,  0..3;
160     is(@count[3] - @count[0], 0, "scalar map expr:  no new tmps per iter");
161     $s = map { qr/1/ && ($count[$_] = sv_count()) && 99 }  0..3;
162     is(@count[3] - @count[0], 0, "scalar map block: no new tmps per iter");
163
164     @a = map qr/1/ && ($count[$_] = sv_count()) && 99,  0..3;
165     is(@count[3] - @count[0], 3, "list   map expr:  one new tmp per iter");
166     @a = map { qr/1/ && ($count[$_] = sv_count()) && 99 }  0..3;
167     is(@count[3] - @count[0], 3, "list   map block: one new tmp per iter");
168
169 }
170
171 SKIP:
172 { # broken by 304474c3, fixed by cefd5c7c, but didn't seem to cause
173   # any other test failures
174   # base test case from ribasushi (Peter Rabbitson)
175   eval { require Scalar::Util; Scalar::Util->import("weaken"); 1; }
176     or skip "no weaken", 1;
177   my $weak;
178   {
179     $weak = my $in = {};
180     weaken($weak);
181     my $out = { in => $in, in => undef }
182   }
183   ok(!$weak, "hash referenced weakened SV released");
184 }
185
186 # prototype() errors
187 leak(2,0, sub { eval { prototype "CORE::fu" } }, 'prototype errors');
188
189 # RT #72246: rcatline memory leak on bad $/
190
191 leak(2, 0,
192     sub {
193         my $f;
194         open CATLINE, '<', \$f;
195         local $/ = "\x{262E}";
196         my $str = "\x{2622}";
197         eval { $str .= <CATLINE> };
198     },
199     "rcatline leak"
200 );
201
202 {
203     my $RE = qr/
204       (?:
205         <(?<tag>
206           \s*
207           [^>\s]+
208         )>
209       )??
210     /xis;
211
212     "<html><body></body></html>" =~ m/$RE/gcs;
213
214     leak(5, 0, sub {
215         my $tag = $+{tag};
216     }, "named regexp captures");
217 }
218
219 eleak(2,0,'/[:]/');
220 eleak(2,0,'/[\xdf]/i');
221 eleak(2,0,'s![^/]!!');
222 eleak(2,0,'/[pp]/');
223 eleak(2,0,'/[[:ascii:]]/');
224 eleak(2,0,'/[[.zog.]]/');
225 eleak(2,0,'/[.zog.]/');
226 eleak(2,0,'chr(0x100) =~ /[[:punct:]]/');
227 eleak(2,0,'chr(0x100) =~ /[[:^punct:]]/');
228 eleak(2,0,'chr(0x100) =~ /\P{Assigned}/');
229 leak(2,0,sub { /(??{})/ }, '/(??{})/');
230
231 leak(2,0,sub { !$^V }, '[perl #109762] version object in boolean context');
232
233
234 # [perl #114356] run-time rexexp with unchanging pattern got
235 # inflated refcounts
236 eleak(2, 0, q{ my $x = "x"; "abc" =~ /$x/ for 1..5 }, '#114356');
237
238 eleak(2, 0, 'sub', '"sub" with nothing following');
239 eleak(2, 0, '+sub:a{}', 'anon subs with invalid attributes');
240 eleak(2, 0, 'no warnings; sub a{1 1}', 'sub with syntax error');
241 eleak(2, 0, 'no warnings; sub {1 1}', 'anon sub with syntax error');
242 eleak(2, 0, 'no warnings; use feature ":all"; my sub a{1 1}',
243      'my sub with syntax error');
244
245 # Reification (or lack thereof)
246 leak(2, 0, sub { sub { local $_[0]; shift }->(1) },
247     'local $_[0] on surreal @_, followed by shift');
248 leak(2, 0, sub { sub { local $_[0]; \@_ }->(1) },
249     'local $_[0] on surreal @_, followed by reification');
250
251 # Syntax errors
252 eleak(2, 0, '"${<<END}"
253                  ', 'unterminated here-doc in quotes in multiline eval');
254 eleak(2, 0, '"${<<END
255                }"', 'unterminated here-doc in multiline quotes in eval');
256 leak(2, 0, sub { eval { do './op/svleak.pl' } },
257         'unterminated here-doc in file');
258 eleak(2, 0, 'tr/9-0//');
259 eleak(2, 0, 'tr/a-z-0//');
260 eleak(2, 0, 'no warnings; nonexistent_function 33838',
261         'bareword followed by number');
262 eleak(2, 0, '//dd;'x20, '"too many errors" when parsing m// flags');
263 eleak(2, 0, 's///dd;'x20, '"too many errors" when parsing s/// flags');
264 eleak(2, 0, 'no warnings; 2 2;BEGIN{}',
265       'BEGIN block after syntax error');
266 {
267     local %INC; # in case Errno is already loaded
268     eleak(2, 0, 'no warnings; 2@!{',
269                 'implicit "use Errno" after syntax error');
270 }
271 eleak(2, 0, "\"\$\0\356\"", 'qq containing $ <null> something');
272 eleak(2, 0, 'END OF TERMS AND CONDITIONS', 'END followed by words');
273 eleak(2, 0, "+ + +;qq|\\N{a}|"x10,'qq"\N{a}" after errors');
274 eleak(2, 0, "qq|\\c|;"x10,     '"too many errors" from qq"\c"');
275 $::TODO = 'still leaks';
276 eleak(2, 0, "qq|\\N{%}|"x10,   '"too many errors" from qq"\N{%}"');
277 undef $::TODO;
278 eleak(2, 0, "qq|\\o|;"x10,     '"too many errors" from qq"\o"');
279 eleak(2, 0, "qq|\\x{|;"x10,    '"too many errors" from qq"\x{"');
280 eleak(2, 0, "qq|\\N|;"x10,     '"too many errors" from qq"\N"');
281 eleak(2, 0, "qq|\\N{|;"x10,    '"too many errors" from qq"\N{"');
282 eleak(2, 0, "qq|\\N{U+GETG}|;"x10,'"too many errors" from qq"\N{U+JUNK}"');
283 $::TODO = 'still leaks';
284 eleak(2, 0, "qq|\\N{au}|;"x10, '"too many errors" from qq"\N{invalid}"');
285 undef $::TODO;
286
287
288 # [perl #114764] Attributes leak scalars
289 leak(2, 0, sub { eval 'my $x : shared' }, 'my $x :shared used to leak');
290
291 eleak(2, 0, 'ref: 1', 'labels');
292
293 # Tied hash iteration was leaking if the hash was freed before itera-
294 # tion was over.
295 package t {
296     sub TIEHASH { bless [] }
297     sub FIRSTKEY { 0 }
298 }
299 leak(2, 0, sub {
300     my $h = {};
301     tie %$h, t;
302     each %$h;
303     undef $h;
304 }, 'tied hash iteration does not leak');
305
306 package explosive_scalar {
307     sub TIESCALAR { my $self = shift; bless [undef, {@_}], $self  }
308     sub FETCH     { die 'FETCH' if $_[0][1]{FETCH}; $_[0][0] }
309     sub STORE     { die 'STORE' if $_[0][1]{STORE}; $_[0][0] = $_[1] }
310 }
311 tie my $die_on_fetch, 'explosive_scalar', FETCH => 1;
312
313 # List assignment was leaking when assigning explosive scalars to
314 # aggregates.
315 leak(2, 0, sub {
316     eval {%a = ($die_on_fetch, 0)}; # key
317     eval {%a = (0, $die_on_fetch)}; # value
318     eval {%a = ($die_on_fetch, $die_on_fetch)}; # both
319 }, 'hash assignment does not leak');
320 leak(2, 0, sub {
321     eval {@a = ($die_on_fetch)};
322     eval {($die_on_fetch, $b) = ($b, $die_on_fetch)};
323     # restore
324     tie $die_on_fetch, 'explosive_scalar', FETCH => 1;
325 }, 'array assignment does not leak');
326
327 # [perl #107000]
328 package hhtie {
329     sub TIEHASH { bless [] }
330     sub STORE    { $_[0][0]{$_[1]} = $_[2] }
331     sub FETCH    { die if $explosive; $_[0][0]{$_[1]} }
332     sub FIRSTKEY { keys %{$_[0][0]}; each %{$_[0][0]} }
333     sub NEXTKEY  { each %{$_[0][0]} }
334 }
335 leak(2, 0, sub {
336     eval q`
337         BEGIN {
338             $hhtie::explosive = 0;
339             tie %^H, hhtie;
340             $^H{foo} = bar;
341             $hhtie::explosive = 1;
342         }
343         { 1; }
344     `;
345 }, 'hint-hash copying does not leak');
346
347 package explosive_array {
348     sub TIEARRAY  { bless [[], {}], $_[0]  }
349     sub FETCH     { die if $_[0]->[1]{FETCH}; $_[0]->[0][$_[1]]  }
350     sub FETCHSIZE { die if $_[0]->[1]{FETCHSIZE}; scalar @{ $_[0]->[0]  }  }
351     sub STORE     { die if $_[0]->[1]{STORE}; $_[0]->[0][$_[1]] = $_[2]  }
352     sub CLEAR     { die if $_[0]->[1]{CLEAR}; @{$_[0]->[0]} = ()  }
353     sub EXTEND    { die if $_[0]->[1]{EXTEND}; return  }
354     sub explode   { my $self = shift; $self->[1] = {@_} }
355 }
356
357 leak(2, 0, sub {
358     tie my @a, 'explosive_array';
359     tied(@a)->explode( STORE => 1 );
360     my $x = 0;
361     eval { @a = ($x)  };
362 }, 'explosive array assignment does not leak');
363
364 leak(2, 0, sub {
365     my ($a, $b);
366     eval { warn $die_on_fetch };
367 }, 'explosive warn argument');
368
369 leak(2, 0, sub {
370     my $foo = sub { return $die_on_fetch };
371     my $res = eval { $foo->() };
372     my @res = eval { $foo->() };
373 }, 'function returning explosive does not leak');
374
375 leak(2, 0, sub {
376     my $res = eval { {$die_on_fetch, 0} };
377     $res = eval { {0, $die_on_fetch} };
378 }, 'building anon hash with explosives does not leak');
379
380 leak(2, 0, sub {
381     my $res = eval { [$die_on_fetch] };
382 }, 'building anon array with explosives does not leak');
383
384 leak(2, 0, sub {
385     my @a;
386     eval { push @a, $die_on_fetch };
387 }, 'pushing exploding scalar does not leak');
388
389 leak(2, 0, sub {
390     eval { push @-, '' };
391 }, 'pushing onto read-only array does not leak');
392
393
394 # Run-time regexp code blocks
395 {
396     use re 'eval';
397     my @tests = ('[(?{})]','(?{})');
398     for my $t (@tests) {
399         leak(2, 0, sub {
400             / $t/;
401         }, "/ \$x/ where \$x is $t does not leak");
402         leak(2, 0, sub {
403             /(?{})$t/;
404         }, "/(?{})\$x/ where \$x is $t does not leak");
405     }
406 }
407
408
409 {
410     use warnings FATAL => 'all';
411     leak(2, 0, sub {
412         no warnings 'once';
413         eval { printf uNopened 42 };
414     }, 'printfing to bad handle under fatal warnings does not leak');
415     open my $fh, ">", \my $buf;
416     leak(2, 0, sub {
417         eval { printf $fh chr 2455 };
418     }, 'wide fatal warning does not make printf leak');
419     close $fh or die $!;
420 }
421
422
423 leak(2,0,sub{eval{require untohunothu}}, 'requiring nonexistent module');