Porting/Maintainers.pl - version's vxs.inc is now CUSTOMIZED as well
[perl.git] / t / perf / benchmarks
1 #!perl
2
3 # This file specifies an array-of-hashes that define snippets of code that
4 # can be run by various measurement and profiling tools.
5 #
6 # The basic idea is that any time you add an optimisation that is intended
7 # to make a particular construct faster, then you should add that construct
8 # to this file.
9 #
10 # Under the normal test suite, the test file benchmarks.t does a basic
11 # compile and run of each of these snippets; not to test performance,
12 # but just to ensure that the code doesn't have errors.
13 #
14 # Over time, it is intended that various measurement and profiling tools
15 # will be written that can run selected (or all) snippets in various
16 # environments. These will not be run as part of a normal test suite run.
17 #
18 # It is intended that the tests in this file will be lightweight; e.g.
19 # a hash access, an empty function call, or a single regex match etc.
20 #
21 # This file is designed to be read in by 'do' (and in such a way that
22 # multiple versions of this file from different releases can be read in
23 # by a single process).
24 #
25 # The top-level array has name/hash pairs (we use an array rather than a
26 # hash so that duplicate keys can be spotted) Each name is a token that
27 # describes a particular test. Code will be compiled in the package named
28 # after the token, so it should match /^(\w|::)+$/a. It is intended that
29 # this can be used on the command line of tools to select particular
30 # tests.
31 # In addition, the package names are arranged into an informal hierarchy
32 # whose top members are (this is subject to change):
33 #
34 #     call::     subroutine and method handling
35 #     expr::     expressions: e.g. $x=1, $foo{bar}[0]
36 #     func::     perl functions, e.g. func::sort::...
37 #     loop::     structural code like for, while(), etc
38 #     regex::    regular expressions
39 #     string::   string handling
40 #
41 #
42 # Each hash has three fields:
43 #
44 #   desc is a description of the test
45 #   setup is a string containing setup code
46 #   code  is a string containing the code to run in a loop
47 #
48 # So typically a benchmark tool might do something like
49 #
50 #   eval "package $token; $setup; for (1..1000000) { $code }"
51 #
52 # Currently the only tool that uses this file is Porting/bench.pl;
53 # try C<perl Porting/bench.pl --help> for more info
54 #
55 # ------
56 #
57 # Note: for the cachegrind variant, an entry like
58 #    'foo::bar' => {
59 #     setup   => 'SETUP',
60 #     code    => 'CODE',
61 #   }
62 # creates two temporary perl sources looking like:
63 #
64 #        package foo::bar;
65 #        BEGIN { srand(0) }
66 #        SETUP;
67 #        for my $__loop__ (1..$ARGV[0]) {
68 #            1;
69 #        }
70 #
71 # and as above, but with the '1;' in the loop  body replaced with:
72 #
73 #            CODE;
74 #
75 # It then pipes each of the two sources into
76 #
77 #     PERL_HASH_SEED=0 valgrind [options] someperl [options] - N
78 #
79 # where N is set to 10 and then 20.
80 #
81 # It then uses the result of those four cachegrind runs to subtract out
82 # the perl startup and loop overheads. So only what's in SETUP and CODE
83 # can affect the benchmark, and if the loop happens to leave some state
84 # changed (such as storing a value in a hash), then the final benchmark
85 # timing is the result of running CODE with the hash entry populated
86 # rather than empty.
87
88
89 [
90     'call::sub::empty' => {
91         desc    => 'function call with no args or body',
92         setup   => 'sub f { }',
93         code    => 'f()',
94     },
95     'call::sub::amp_empty' => {
96         desc    => '&foo function call with no args or body',
97         setup   => 'sub f { }; @_ = ();',
98         code    => '&f',
99     },
100     'call::sub::args3' => {
101         desc    => 'function call with 3 local lexical vars',
102         setup   => 'sub f { my ($a, $b, $c) = @_; 1 }',
103         code    => 'f(1,2,3)',
104     },
105     'call::sub::args2_ret1' => {
106         desc    => 'function call with 2 local lex vars and 1 return value',
107         setup   => 'my $x; sub f { my ($a, $b) = @_; $a+$b }',
108         code    => '$x = f(1,2)',
109     },
110     'call::sub::args2_ret1temp' => {
111         desc    => 'function call with 2 local lex vars and 1 return TEMP value',
112         setup   => 'my $x; sub f { my ($a, $b) = @_; \$a }',
113         code    => '$x = f(1,2)',
114     },
115     'call::sub::args3_ret3' => {
116         desc    => 'function call with 3 local lex vars and 3 return values',
117         setup   => 'my @a; sub f { my ($a, $b, $c) = @_; $a+$b, $c, 1 }',
118         code    => '@a = f(1,2,3)',
119     },
120     'call::sub::args3_ret3str' => {
121         desc    => 'function call with 3 local lex vars and 3 string return values',
122         setup   => 'my @a; sub f { my ($a, $b, $c) = @_; my @s = ("aa","bb","cc"); @s }',
123         code    => '@a = f(1,2,3)',
124     },
125     'call::sub::args3_ret3temp' => {
126         desc    => 'function call with 3 local lex vars and 3 TEMP return values',
127         setup   => 'my @a; sub f { my ($a, $b, $c) = @_; 1..3 }',
128         code    => '@a = f(1,2,3)',
129     },
130     'call::sub::recursive' => {
131         desc    => 'basic recursive function call',
132         setup   => 'my $x; sub f { my ($i) = @_; $i > 0 ? $i + f($i-1) : 0 }',
133         code    => '$x = f(1)',
134     },
135
136     'call::goto::empty' => {
137         desc    => 'goto &funtion with no args or body',
138         setup   => 'sub f { goto &g } sub g {}',
139         code    => 'f()',
140     },
141     'call::goto::args3' => {
142         desc    => 'goto &funtion with 3 local lexical vars',
143         setup   => 'sub f { goto &g } sub g { my ($a, $b, $c) = @_ }',
144         code    => 'f(1,2,3)',
145     },
146
147
148     'expr::array::lex_1const_0' => {
149         desc    => 'lexical $array[0]',
150         setup   => 'my @a = (1)',
151         code    => '$a[0]',
152     },
153     'expr::array::lex_1const_m1' => {
154         desc    => 'lexical $array[-1]',
155         setup   => 'my @a = (1)',
156         code    => '$a[-1]',
157     },
158     'expr::array::lex_2const' => {
159         desc    => 'lexical $array[const][const]',
160         setup   => 'my @a = ([1,2])',
161         code    => '$a[0][1]',
162     },
163     'expr::array::lex_2var' => {
164         desc    => 'lexical $array[$i1][$i2]',
165         setup   => 'my ($i1,$i2) = (0,1); my @a = ([1,2])',
166         code    => '$a[$i1][$i2]',
167     },
168     'expr::array::ref_lex_2var' => {
169         desc    => 'lexical $arrayref->[$i1][$i2]',
170         setup   => 'my ($i1,$i2) = (0,1); my $r = [[1,2]]',
171         code    => '$r->[$i1][$i2]',
172     },
173     'expr::array::ref_lex_3const' => {
174         desc    => 'lexical $arrayref->[const][const][const]',
175         setup   => 'my $r = [[[1,2]]]',
176         code    => '$r->[0][0][0]',
177     },
178     'expr::array::ref_expr_lex_3const' => {
179         desc    => '(lexical expr)->[const][const][const]',
180         setup   => 'my $r = [[[1,2]]]',
181         code    => '($r||0)->[0][0][0]',
182     },
183
184
185     'expr::array::pkg_1const_0' => {
186         desc    => 'package $array[0]',
187         setup   => '@a = (1)',
188         code    => '$a[0]',
189     },
190     'expr::array::pkg_1const_m1' => {
191         desc    => 'package $array[-1]',
192         setup   => '@a = (1)',
193         code    => '$a[-1]',
194     },
195     'expr::array::pkg_2const' => {
196         desc    => 'package $array[const][const]',
197         setup   => '@a = ([1,2])',
198         code    => '$a[0][1]',
199     },
200     'expr::array::pkg_2var' => {
201         desc    => 'package $array[$i1][$i2]',
202         setup   => '($i1,$i2) = (0,1); @a = ([1,2])',
203         code    => '$a[$i1][$i2]',
204     },
205     'expr::array::ref_pkg_2var' => {
206         desc    => 'package $arrayref->[$i1][$i2]',
207         setup   => '($i1,$i2) = (0,1); $r = [[1,2]]',
208         code    => '$r->[$i1][$i2]',
209     },
210     'expr::array::ref_pkg_3const' => {
211         desc    => 'package $arrayref->[const][const][const]',
212         setup   => '$r = [[[1,2]]]',
213         code    => '$r->[0][0][0]',
214     },
215     'expr::array::ref_expr_pkg_3const' => {
216         desc    => '(package expr)->[const][const][const]',
217         setup   => '$r = [[[1,2]]]',
218         code    => '($r||0)->[0][0][0]',
219     },
220
221     'expr::array::lex_bool_empty' => {
222         desc    => 'empty lexical array in boolean context',
223         setup   => 'my @a;',
224         code    => '!@a',
225     },
226     'expr::array::lex_bool_full' => {
227         desc    => 'non-empty lexical array in boolean context',
228         setup   => 'my @a = 1..10;',
229         code    => '!@a',
230     },
231     'expr::array::lex_scalar_empty' => {
232         desc    => 'empty lexical array in scalar context',
233         setup   => 'my (@a, $i);',
234         code    => '$i = @a',
235     },
236     'expr::array::lex_scalar_full' => {
237         desc    => 'non-empty lexical array in scalar context',
238         setup   => 'my @a = 1..10; my $i',
239         code    => '$i = @a',
240     },
241     'expr::array::pkg_bool_empty' => {
242         desc    => 'empty lexical array in boolean context',
243         setup   => 'our @a;',
244         code    => '!@a',
245     },
246     'expr::array::pkg_bool_full' => {
247         desc    => 'non-empty lexical array in boolean context',
248         setup   => 'our @a = 1..10;',
249         code    => '!@a',
250     },
251     'expr::array::pkg_scalar_empty' => {
252         desc    => 'empty lexical array in scalar context',
253         setup   => 'our @a; my $i;',
254         code    => '$i = @a',
255     },
256     'expr::array::pkg_scalar_full' => {
257         desc    => 'non-empty lexical array in scalar context',
258         setup   => 'our @a = 1..10; my $i',
259         code    => '$i = @a',
260     },
261
262     'expr::arrayhash::lex_3var' => {
263         desc    => 'lexical $h{$k1}[$i]{$k2}',
264         setup   => 'my ($i, $k1, $k2) = (0,"foo","bar");'
265                     . 'my %h = (foo => [ { bar => 1 } ])',
266         code    => '$h{$k1}[$i]{$k2}',
267     },
268     'expr::arrayhash::pkg_3var' => {
269         desc    => 'package $h{$k1}[$i]{$k2}',
270         setup   => '($i, $k1, $k2) = (0,"foo","bar");'
271                     . '%h = (foo => [ { bar => 1 } ])',
272         code    => '$h{$k1}[$i]{$k2}',
273     },
274
275     'expr::hash::lex_1const' => {
276         desc    => 'lexical $hash{const}',
277         setup   => 'my %h = ("foo" => 1)',
278         code    => '$h{foo}',
279     },
280     'expr::hash::lex_2const' => {
281         desc    => 'lexical $hash{const}{const}',
282         setup   => 'my %h = (foo => { bar => 1 })',
283         code    => '$h{foo}{bar}',
284     },
285     'expr::hash::lex_2var' => {
286         desc    => 'lexical $hash{$k1}{$k2}',
287         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 })',
288         code    => '$h{$k1}{$k2}',
289     },
290     'expr::hash::ref_lex_2var' => {
291         desc    => 'lexical $hashref->{$k1}{$k2}',
292         setup   => 'my ($k1,$k2) = qw(foo bar); my $r = {$k1 => { $k2 => 1 }}',
293         code    => '$r->{$k1}{$k2}',
294     },
295     'expr::hash::ref_lex_3const' => {
296         desc    => 'lexical $hashref->{const}{const}{const}',
297         setup   => 'my $r = {foo => { bar => { baz => 1 }}}',
298         code    => '$r->{foo}{bar}{baz}',
299     },
300     'expr::hash::ref_expr_lex_3const' => {
301         desc    => '(lexical expr)->{const}{const}{const}',
302         setup   => 'my $r = {foo => { bar => { baz => 1 }}}',
303         code    => '($r||0)->{foo}{bar}{baz}',
304     },
305
306     'expr::hash::pkg_1const' => {
307         desc    => 'package $hash{const}',
308         setup   => '%h = ("foo" => 1)',
309         code    => '$h{foo}',
310     },
311     'expr::hash::pkg_2const' => {
312         desc    => 'package $hash{const}{const}',
313         setup   => '%h = (foo => { bar => 1 })',
314         code    => '$h{foo}{bar}',
315     },
316     'expr::hash::pkg_2var' => {
317         desc    => 'package $hash{$k1}{$k2}',
318         setup   => '($k1,$k2) = qw(foo bar); %h = ($k1 => { $k2 => 1 })',
319         code    => '$h{$k1}{$k2}',
320     },
321     'expr::hash::ref_pkg_2var' => {
322         desc    => 'package $hashref->{$k1}{$k2}',
323         setup   => '($k1,$k2) = qw(foo bar); $r = {$k1 => { $k2 => 1 }}',
324         code    => '$r->{$k1}{$k2}',
325     },
326     'expr::hash::ref_pkg_3const' => {
327         desc    => 'package $hashref->{const}{const}{const}',
328         setup   => '$r = {foo => { bar => { baz => 1 }}}',
329         code    => '$r->{foo}{bar}{baz}',
330     },
331     'expr::hash::ref_expr_pkg_3const' => {
332         desc    => '(package expr)->{const}{const}{const}',
333         setup   => '$r = {foo => { bar => { baz => 1 }}}',
334         code    => '($r||0)->{foo}{bar}{baz}',
335     },
336
337
338     'expr::hash::exists_lex_2var' => {
339         desc    => 'lexical exists $hash{$k1}{$k2}',
340         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 });',
341         code    => 'exists $h{$k1}{$k2}',
342     },
343
344     'expr::hash::bool_empty' => {
345         desc    => 'empty lexical hash in boolean context',
346         setup   => 'my %h;',
347         code    => '!%h',
348     },
349     'expr::hash::bool_empty_unknown' => {
350         desc    => 'empty lexical hash in unknown context',
351         setup   => 'my ($i, %h); sub f { if (%h) { $i++ }}',
352         code    => 'f()',
353     },
354     'expr::hash::bool_full' => {
355         desc    => 'non-empty lexical hash in boolean context',
356         setup   => 'my %h = 1..10;',
357         code    => '!%h',
358     },
359
360
361     (
362         map {
363             sprintf('expr::hash::notexists_lex_keylen%04d',$_) => {
364                 desc    => 'exists on non-key of length '. $_,
365                 setup   => 'my %h; my $key = "A" x ' . $_ . '; $h{$key."x"} = 1;',
366                 code    => 'exists $h{$key}',
367             },
368         } (
369             1 .. 24,
370             # 1,2,3,7,8,9,14,15,16,20,24,
371             50,
372             100,
373             1000,
374         )
375     ),
376     (
377         map {
378             sprintf('expr::hash::exists_lex_keylen%04d',$_) => {
379                 desc    => 'exists on existing key of length '. $_,
380                 setup   => 'my %h; my $key = "A" x ' . $_ . '; $h{$key} = 1;',
381                 code    => 'exists $h{$key}',
382             },
383         } (
384             1 .. 24,
385             # 1,2,3,7,8,9,14,15,16,20,24,
386             50,
387             100,
388             1000,
389         )
390     ),
391
392     'expr::hash::delete_lex_2var' => {
393         desc    => 'lexical delete $hash{$k1}{$k2}',
394         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 });',
395         code    => 'delete $h{$k1}{$k2}',
396     },
397
398
399     # list assign, OP_AASSIGN
400
401
402     # (....) = ()
403
404     'expr::aassign::ma_empty' => {
405         desc    => 'my array assigned empty',
406         setup   => '',
407         code    => 'my @a = ()',
408     },
409     'expr::aassign::lax_empty' => {
410         desc    => 'non-empty lexical array assigned empty',
411         setup   => 'my @a = 1..3;',
412         code    => '@a = ()',
413     },
414     'expr::aassign::llax_empty' => {
415         desc    => 'non-empty lexical var and array assigned empty',
416         setup   => 'my ($x, @a) = 1..4;',
417         code    => '($x, @a) = ()',
418     },
419     'expr::aassign::mh_empty' => {
420         desc    => 'my hash assigned empty',
421         setup   => '',
422         code    => 'my %h = ()',
423     },
424     'expr::aassign::lhx_empty' => {
425         desc    => 'non-empty lexical hash assigned empty',
426         setup   => 'my %h = 1..4;',
427         code    => '%h = ()',
428     },
429     'expr::aassign::llhx_empty' => {
430         desc    => 'non-empty lexical var and hash assigned empty',
431         setup   => 'my ($x, %h) = 1..5;',
432         code    => '($x, %h) = ()',
433     },
434     'expr::aassign::3m_empty' => {
435         desc    => 'three my vars assigned empty',
436         setup   => '',
437         code    => 'my ($x,$y,$z) = ()',
438     },
439     'expr::aassign::3l_empty' => {
440         desc    => 'three lexical vars assigned empty',
441         setup   => 'my ($x,$y,$z)',
442         code    => '($x,$y,$z) = ()',
443     },
444     'expr::aassign::3lref_empty' => {
445         desc    => 'three lexical ref vars assigned empty',
446         setup   => 'my ($x,$y,$z); my $r = []; ',
447         code    => '($x,$y,$z) = ($r,$r,$r); ($x,$y,$z) = ()',
448     },
449     'expr::aassign::pa_empty' => {
450         desc    => 'package array assigned empty',
451         setup   => '',
452         code    => '@a = ()',
453     },
454     'expr::aassign::pax_empty' => {
455         desc    => 'non-empty package array assigned empty',
456         setup   => '@a = (1,2,3)',
457         code    => '@a = ()',
458     },
459     'expr::aassign::3p_empty' => {
460         desc    => 'three package vars assigned empty',
461         setup   => '($x,$y,$z) = 1..3;',
462         code    => '($x,$y,$z) = ()',
463     },
464
465     # (....) = (1,2,3)
466
467     'expr::aassign::ma_3c' => {
468         desc    => 'my array assigned 3 consts',
469         setup   => '',
470         code    => 'my @a = (1,2,3)',
471     },
472     'expr::aassign::lax_3c' => {
473         desc    => 'non-empty lexical array assigned 3 consts',
474         setup   => 'my @a = 1..3;',
475         code    => '@a = (1,2,3)',
476     },
477     'expr::aassign::llax_3c' => {
478         desc    => 'non-empty lexical var and array assigned 3 consts',
479         setup   => 'my ($x, @a) = 1..4;',
480         code    => '($x, @a) = (1,2,3)',
481     },
482     'expr::aassign::mh_4c' => {
483         desc    => 'my hash assigned 4 consts',
484         setup   => '',
485         code    => 'my %h = qw(a 1 b 2)',
486     },
487     'expr::aassign::lhx_4c' => {
488         desc    => 'non-empty lexical hash assigned 4 consts',
489         setup   => 'my %h = qw(a 1 b 2);',
490         code    => '%h = qw(c 3 d 4)',
491     },
492     'expr::aassign::llhx_5c' => {
493         desc    => 'non-empty lexical var and array assigned 5 consts',
494         setup   => 'my ($x, %h) = (1, qw(a 1 b 2));',
495         code    => '($x, %h) = (10, qw(c 3 d 4))',
496     },
497     'expr::aassign::3m_3c' => {
498         desc    => 'three my vars assigned 3 consts',
499         setup   => '',
500         code    => 'my ($x,$y,$z) = (1,2,3)',
501     },
502     'expr::aassign::3l_3c' => {
503         desc    => 'three lexical vars assigned 3 consts',
504         setup   => 'my ($x,$y,$z)',
505         code    => '($x,$y,$z) = (1,2,3)',
506     },
507     'expr::aassign::pa_3c' => {
508         desc    => 'package array assigned 3 consts',
509         setup   => '',
510         code    => '@a = (1,2,3)',
511     },
512     'expr::aassign::pax_3c' => {
513         desc    => 'non-empty package array assigned 3 consts',
514         setup   => '@a = (1,2,3)',
515         code    => '@a = (1,2,3)',
516     },
517     'expr::aassign::3p_3c' => {
518         desc    => 'three package vars assigned 3 consts',
519         setup   => '($x,$y,$z) = 1..3;',
520         code    => '($x,$y,$z) = (1,2,3)',
521     },
522
523     # (....) = @lexical
524
525     'expr::aassign::ma_la' => {
526         desc    => 'my array assigned lexical array',
527         setup   => 'my @init = 1..3;',
528         code    => 'my @a = @init',
529     },
530     'expr::aassign::lax_la' => {
531         desc    => 'non-empty lexical array assigned lexical array',
532         setup   => 'my @init = 1..3; my @a = 1..3;',
533         code    => '@a = @init',
534     },
535     'expr::aassign::llax_la' => {
536         desc    => 'non-empty lexical var and array assigned lexical array',
537         setup   => 'my @init = 1..3; my ($x, @a) = 1..4;',
538         code    => '($x, @a) = @init',
539     },
540     'expr::aassign::3m_la' => {
541         desc    => 'three my vars assigned lexical array',
542         setup   => 'my @init = 1..3;',
543         code    => 'my ($x,$y,$z) = @init',
544     },
545     'expr::aassign::3l_la' => {
546         desc    => 'three lexical vars assigned lexical array',
547         setup   => 'my @init = 1..3; my ($x,$y,$z)',
548         code    => '($x,$y,$z) = @init',
549     },
550     'expr::aassign::pa_la' => {
551         desc    => 'package array assigned lexical array',
552         setup   => 'my @init = 1..3;',
553         code    => '@a = @init',
554     },
555     'expr::aassign::pax_la' => {
556         desc    => 'non-empty package array assigned lexical array',
557         setup   => 'my @init = 1..3; @a = @init',
558         code    => '@a = @init',
559     },
560     'expr::aassign::3p_la' => {
561         desc    => 'three package vars assigned lexical array',
562         setup   => 'my @init = 1..3; ($x,$y,$z) = 1..3;',
563         code    => '($x,$y,$z) = @init',
564     },
565
566     # (....) = @package
567
568     'expr::aassign::ma_pa' => {
569         desc    => 'my array assigned package array',
570         setup   => '@init = 1..3;',
571         code    => 'my @a = @init',
572     },
573     'expr::aassign::lax_pa' => {
574         desc    => 'non-empty lexical array assigned package array',
575         setup   => '@init = 1..3; my @a = 1..3;',
576         code    => '@a = @init',
577     },
578     'expr::aassign::llax_pa' => {
579         desc    => 'non-empty lexical var and array assigned package array',
580         setup   => '@init = 1..3; my ($x, @a) = 1..4;',
581         code    => '($x, @a) = @init',
582     },
583     'expr::aassign::3m_pa' => {
584         desc    => 'three my vars assigned package array',
585         setup   => '@init = 1..3;',
586         code    => 'my ($x,$y,$z) = @init',
587     },
588     'expr::aassign::3l_pa' => {
589         desc    => 'three lexical vars assigned package array',
590         setup   => '@init = 1..3; my ($x,$y,$z)',
591         code    => '($x,$y,$z) = @init',
592     },
593     'expr::aassign::pa_pa' => {
594         desc    => 'package array assigned package array',
595         setup   => '@init = 1..3;',
596         code    => '@a = @init',
597     },
598     'expr::aassign::pax_pa' => {
599         desc    => 'non-empty package array assigned package array',
600         setup   => '@init = 1..3; @a = @init',
601         code    => '@a = @init',
602     },
603     'expr::aassign::3p_pa' => {
604         desc    => 'three package vars assigned package array',
605         setup   => '@init = 1..3; ($x,$y,$z) = 1..3;',
606         code    => '($x,$y,$z) = @init',
607     },
608
609     # (....) = @_;
610
611     'expr::aassign::ma_defary' => {
612         desc    => 'my array assigned @_',
613         setup   => '@_ = 1..3;',
614         code    => 'my @a = @_',
615     },
616     'expr::aassign::lax_defary' => {
617         desc    => 'non-empty lexical array assigned @_',
618         setup   => '@_ = 1..3; my @a = 1..3;',
619         code    => '@a = @_',
620     },
621     'expr::aassign::llax_defary' => {
622         desc    => 'non-empty lexical var and array assigned @_',
623         setup   => '@_ = 1..3; my ($x, @a) = 1..4;',
624         code    => '($x, @a) = @_',
625     },
626     'expr::aassign::3m_defary' => {
627         desc    => 'three my vars assigned @_',
628         setup   => '@_ = 1..3;',
629         code    => 'my ($x,$y,$z) = @_',
630     },
631     'expr::aassign::3l_defary' => {
632         desc    => 'three lexical vars assigned @_',
633         setup   => '@_ = 1..3; my ($x,$y,$z)',
634         code    => '($x,$y,$z) = @_',
635     },
636     'expr::aassign::pa_defary' => {
637         desc    => 'package array assigned @_',
638         setup   => '@_ = 1..3;',
639         code    => '@a = @_',
640     },
641     'expr::aassign::pax_defary' => {
642         desc    => 'non-empty package array assigned @_',
643         setup   => '@_ = 1..3; @a = @_',
644         code    => '@a = @_',
645     },
646     'expr::aassign::3p_defary' => {
647         desc    => 'three package vars assigned @_',
648         setup   => '@_ = 1..3; ($x,$y,$z) = 1..3;',
649         code    => '($x,$y,$z) = @_',
650     },
651
652     # (....) = %lexical
653
654     'expr::aassign::ma_lh' => {
655         desc    => 'my array assigned lexical hash',
656         setup   => 'my %h = qw(aardvark 1 banana 2 cucumber 3)',
657         code    => 'my @a = %h',
658     },
659
660
661     # (....) = ($lex1,$lex2,$lex3);
662
663     'expr::aassign::ma_3l' => {
664         desc    => 'my array assigned lexicals',
665         setup   => 'my ($v1,$v2,$v3) = 1..3;',
666         code    => 'my @a = ($v1,$v2,$v3)',
667     },
668     'expr::aassign::lax_3l' => {
669         desc    => 'non-empty lexical array assigned lexicals',
670         setup   => 'my ($v1,$v2,$v3) = 1..3; my @a = 1..3;',
671         code    => '@a = ($v1,$v2,$v3)',
672     },
673     'expr::aassign::llax_3l' => {
674         desc    => 'non-empty lexical var and array assigned lexicals',
675         setup   => 'my ($v1,$v2,$v3) = 1..3; my ($x, @a) = 1..4;',
676         code    => '($x, @a) = ($v1,$v2,$v3)',
677     },
678     'expr::aassign::3m_3l' => {
679         desc    => 'three my vars assigned lexicals',
680         setup   => 'my ($v1,$v2,$v3) = 1..3;',
681         code    => 'my ($x,$y,$z) = ($v1,$v2,$v3)',
682     },
683     'expr::aassign::3l_3l' => {
684         desc    => 'three lexical vars assigned lexicals',
685         setup   => 'my ($v1,$v2,$v3) = 1..3; my ($x,$y,$z)',
686         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
687     },
688     'expr::aassign::pa_3l' => {
689         desc    => 'package array assigned lexicals',
690         setup   => 'my ($v1,$v2,$v3) = 1..3;',
691         code    => '@a = ($v1,$v2,$v3)',
692     },
693     'expr::aassign::pax_3l' => {
694         desc    => 'non-empty package array assigned lexicals',
695         setup   => 'my ($v1,$v2,$v3) = 1..3; @a = @_',
696         code    => '@a = ($v1,$v2,$v3)',
697     },
698     'expr::aassign::3p_3l' => {
699         desc    => 'three package vars assigned lexicals',
700         setup   => 'my ($v1,$v2,$v3) = 1..3; ($x,$y,$z) = 1..3;',
701         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
702     },
703
704
705     # (....) = ($pkg1,$pkg2,$pkg3);
706
707     'expr::aassign::ma_3p' => {
708         desc    => 'my array assigned 3 package vars',
709         setup   => '($v1,$v2,$v3) = 1..3;',
710         code    => 'my @a = ($v1,$v2,$v3)',
711     },
712     'expr::aassign::lax_3p' => {
713         desc    => 'non-empty lexical array assigned 3 package vars',
714         setup   => '($v1,$v2,$v3) = 1..3; my @a = 1..3;',
715         code    => '@a = ($v1,$v2,$v3)',
716     },
717     'expr::aassign::llax_3p' => {
718         desc    => 'non-empty lexical var and array assigned 3 package vars',
719         setup   => '($v1,$v2,$v3) = 1..3; my ($x, @a) = 1..4;',
720         code    => '($x, @a) = ($v1,$v2,$v3)',
721     },
722     'expr::aassign::3m_3p' => {
723         desc    => 'three my vars assigned 3 package vars',
724         setup   => '($v1,$v2,$v3) = 1..3;',
725         code    => 'my ($x,$y,$z) = ($v1,$v2,$v3)',
726     },
727     'expr::aassign::3l_3p' => {
728         desc    => 'three lexical vars assigned 3 package vars',
729         setup   => '($v1,$v2,$v3) = 1..3; my ($x,$y,$z)',
730         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
731     },
732     'expr::aassign::pa_3p' => {
733         desc    => 'package array assigned 3 package vars',
734         setup   => '($v1,$v2,$v3) = 1..3;',
735         code    => '@a = ($v1,$v2,$v3)',
736     },
737     'expr::aassign::pax_3p' => {
738         desc    => 'non-empty package array assigned 3 package vars',
739         setup   => '($v1,$v2,$v3) = 1..3; @a = @_',
740         code    => '@a = ($v1,$v2,$v3)',
741     },
742     'expr::aassign::3p_3p' => {
743         desc    => 'three package vars assigned 3 package vars',
744         setup   => '($v1,$v2,$v3) = 1..3; ($x,$y,$z) = 1..3;',
745         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
746     },
747
748
749     # (....) = (1,2,$shared);
750
751     'expr::aassign::llax_2c1s' => {
752         desc    => 'non-empty lexical var and array assigned 2 consts and 1 shared var',
753         setup   => 'my ($x, @a) = 1..4;',
754         code    => '($x, @a) = (1,2,$x)',
755     },
756     'expr::aassign::3l_2c1s' => {
757         desc    => 'three lexical vars assigned 2 consts and 1 shared var',
758         setup   => 'my ($x,$y,$z) = 1..3;',
759         code    => '($x,$y,$z) = (1,2,$x)',
760     },
761     'expr::aassign::3p_2c1s' => {
762         desc    => 'three package vars assigned 2 consts and 1 shared var',
763         setup   => '($x,$y,$z) = 1..3;',
764         code    => '($x,$y,$z) = (1,2,$x)',
765     },
766
767
768     # ($a,$b) = ($b,$a);
769
770     'expr::aassign::2l_swap' => {
771         desc    => 'swap two lexical vars',
772         setup   => 'my ($a,$b) = (1,2)',
773         code    => '($a,$b) = ($b,$a)',
774     },
775     'expr::aassign::2p_swap' => {
776         desc    => 'swap two package vars',
777         setup   => '($a,$b) = (1,2)',
778         code    => '($a,$b) = ($b,$a)',
779     },
780     'expr::aassign::2laelem_swap' => {
781         desc    => 'swap two lexical vars',
782         setup   => 'my @a = (1,2)',
783         code    => '($a[0],$a[1]) = ($a[1],$a[0])',
784     },
785
786     # misc list assign
787
788     'expr::aassign::5l_4l1s' => {
789         desc    => 'long list of lexical vars, 1 shared',
790         setup   => 'my ($a,$b,$c,$d,$e) = 1..5',
791         code    => '($a,$b,$c,$d,$e) = ($a,$a,$c,$d,$e)',
792     },
793
794     'expr::aassign::5p_4p1s' => {
795         desc    => 'long list of package vars, 1 shared',
796         setup   => '($a,$b,$c,$d,$e) = 1..5',
797         code    => '($a,$b,$c,$d,$e) = ($a,$a,$c,$d,$e)',
798     },
799     'expr::aassign::5l_defary' => {
800         desc    => 'long list of lexical vars to assign @_ to',
801         setup   => '@_ = 1..5',
802         code    => 'my ($a,$b,$c,$d,$e) = @_',
803     },
804     'expr::aassign::5l1la_defary' => {
805         desc    => 'long list of lexical vars plus long slurp to assign @_ to',
806         setup   => '@_ = 1..20',
807         code    => 'my ($a,$b,$c,$d,$e,@rest) = @_',
808     },
809     'expr::aassign::1l_2l' => {
810         desc    => 'single lexical LHS',
811         setup   => 'my $x = 1;',
812         code    => '(undef,$x) = ($x,$x)',
813     },
814     'expr::aassign::2l_1l' => {
815         desc    => 'single lexical RHS',
816         setup   => 'my $x = 1;',
817         code    => '($x,$x) = ($x)',
818     },
819     'expr::aassign::2l_1ul' => {
820         desc    => 'undef and single lexical RHS',
821         setup   => 'my $x = 1;',
822         code    => '($x,$x) = (undef, $x)',
823     },
824
825     'expr::aassign::2list_lex' => {
826         desc    => 'lexical ($x, $y) = (1, 2)',
827         setup   => 'my ($x, $y)',
828         code    => '($x, $y) = (1, 2)',
829     },
830
831     'expr::aassign::lex_rv' => {
832         desc    => 'lexical ($ref1, $ref2) = ($ref3, $ref4)',
833         setup   => 'my ($r1, $r2, $r3, $r4);
834                     ($r1, $r2) = (($r3, $r4) = ([],  []));',
835         code    => '($r1, $r2) = ($r3, $r4)',
836     },
837
838     'expr::aassign::lex_rv1' => {
839         desc    => 'lexical ($ref1, $ref2) = ($ref3, $ref4) where ref1,2 are freed',
840         setup   => 'my ($r1, $r2);',
841         code    => '($r1, $r2) = ([], []);',
842     },
843
844     'expr::aassign::boolean' => {
845         desc    => '!(@a = @b)',
846         setup   => 'my ($s,@a, @b); @b = (1,2)',
847         code    => '!(@a = @b);',
848     },
849     'expr::aassign::scalar' => {
850         desc    => '$scalar = (@a = @b)',
851         setup   => 'my ($s, @a, @b); @b = (1,2)',
852         code    => '$s = (@a = @b);',
853     },
854
855     # array assign of strings
856
857     'expr::aassign::la_3s' => {
858         desc    => 'assign 3 strings to empty lexical array',
859         setup   => 'my @a',
860         code    => '@a = (); @a = qw(abc defg hijkl);',
861     },
862     'expr::aassign::la_3ts' => {
863         desc    => 'assign 3 temp strings to empty lexical array',
864         setup   => 'my @a',
865         code    => '@a = (); @a = map $_, qw(abc defg hijkl);',
866     },
867     'expr::aassign::lan_3s' => {
868         desc    => 'assign 3 strings to non-empty lexical array',
869         setup   => 'my @a = qw(abc defg hijkl)',
870         code    => '@a = qw(abc defg hijkl);',
871     },
872     'expr::aassign::lan_3ts' => {
873         desc    => 'assign 3 temp strings to non-empty lexical array',
874         setup   => 'my @a = qw(abc defg hijkl)',
875         code    => '@a = map $_, qw(abc defg hijkl);',
876     },
877
878     # hash assign of strings
879
880     'expr::aassign::lh_2s' => {
881         desc    => 'assign 2 strings to empty lexical hash',
882         setup   => 'my %h',
883         code    => '%h = (); %h = qw(k1 abc k2 defg);',
884     },
885     'expr::aassign::lh_2ts' => {
886         desc    => 'assign 2 temp strings to empty lexical hash',
887         setup   => 'my %h',
888         code    => '%h = (); %h = map $_, qw(k1 abc k2 defg);',
889     },
890     'expr::aassign::lhn_2s' => {
891         desc    => 'assign 2 strings to non-empty lexical hash',
892         setup   => 'my %h = qw(k1 abc k2 defg);',
893         code    => '%h = qw(k1 abc k2 defg);',
894     },
895     'expr::aassign::lhn_2ts' => {
896         desc    => 'assign 2 temp strings to non-empty lexical hash',
897         setup   => 'my %h = qw(k1 abc k2 defg);',
898         code    => '%h = map $_, qw(k1 abc k2 defg);',
899     },
900
901
902     'expr::arith::add_lex_ii' => {
903         desc    => 'add two integers and assign to a lexical var',
904         setup   => 'my ($x,$y,$z) = 1..3;',
905         code    => '$z = $x + $y',
906     },
907     'expr::arith::add_pkg_ii' => {
908         desc    => 'add two integers and assign to a package var',
909         setup   => 'my ($x,$y) = 1..2; $z = 3;',
910         code    => '$z = $x + $y',
911     },
912     'expr::arith::add_lex_nn' => {
913         desc    => 'add two NVs and assign to a lexical var',
914         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
915         code    => '$z = $x + $y',
916     },
917     'expr::arith::add_pkg_nn' => {
918         desc    => 'add two NVs and assign to a package var',
919         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
920         code    => '$z = $x + $y',
921     },
922     'expr::arith::add_lex_ni' => {
923         desc    => 'add an int and an NV and assign to a lexical var',
924         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
925         code    => '$z = $x + $y',
926     },
927     'expr::arith::add_pkg_ni' => {
928         desc    => 'add an int and an NV and assign to a package var',
929         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
930         code    => '$z = $x + $y',
931     },
932     'expr::arith::add_lex_ss' => {
933         desc    => 'add two short strings and assign to a lexical var',
934         setup   => 'my ($x,$y,$z) = ("1", "2", 1);',
935         code    => '$z = $x + $y; $x = "1"; ',
936     },
937
938     'expr::arith::add_lex_ll' => {
939         desc    => 'add two long strings and assign to a lexical var',
940         setup   => 'my ($x,$y,$z) = ("12345", "23456", 1);',
941         code    => '$z = $x + $y; $x = "12345"; ',
942     },
943
944     'expr::arith::sub_lex_ii' => {
945         desc    => 'subtract two integers and assign to a lexical var',
946         setup   => 'my ($x,$y,$z) = 1..3;',
947         code    => '$z = $x - $y',
948     },
949     'expr::arith::sub_pkg_ii' => {
950         desc    => 'subtract two integers and assign to a package var',
951         setup   => 'my ($x,$y) = 1..2; $z = 3;',
952         code    => '$z = $x - $y',
953     },
954     'expr::arith::sub_lex_nn' => {
955         desc    => 'subtract two NVs and assign to a lexical var',
956         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
957         code    => '$z = $x - $y',
958     },
959     'expr::arith::sub_pkg_nn' => {
960         desc    => 'subtract two NVs and assign to a package var',
961         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
962         code    => '$z = $x - $y',
963     },
964     'expr::arith::sub_lex_ni' => {
965         desc    => 'subtract an int and an NV and assign to a lexical var',
966         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
967         code    => '$z = $x - $y',
968     },
969     'expr::arith::sub_pkg_ni' => {
970         desc    => 'subtract an int and an NV and assign to a package var',
971         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
972         code    => '$z = $x - $y',
973     },
974
975     'expr::arith::mult_lex_ii' => {
976         desc    => 'multiply two integers and assign to a lexical var',
977         setup   => 'my ($x,$y,$z) = 1..3;',
978         code    => '$z = $x * $y',
979     },
980     'expr::arith::mult_pkg_ii' => {
981         desc    => 'multiply two integers and assign to a package var',
982         setup   => 'my ($x,$y) = 1..2; $z = 3;',
983         code    => '$z = $x * $y',
984     },
985     'expr::arith::mult_lex_nn' => {
986         desc    => 'multiply two NVs and assign to a lexical var',
987         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
988         code    => '$z = $x * $y',
989     },
990     'expr::arith::mult_pkg_nn' => {
991         desc    => 'multiply two NVs and assign to a package var',
992         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
993         code    => '$z = $x * $y',
994     },
995     'expr::arith::mult_lex_ni' => {
996         desc    => 'multiply an int and an NV and assign to a lexical var',
997         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
998         code    => '$z = $x * $y',
999     },
1000     'expr::arith::mult_pkg_ni' => {
1001         desc    => 'multiply an int and an NV and assign to a package var',
1002         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
1003         code    => '$z = $x * $y',
1004     },
1005
1006     # use '!' to test SvTRUE on various classes of value
1007
1008     'expr::arith::not_PL_undef' => {
1009         desc    => '!undef (using PL_sv_undef)',
1010         setup   => 'my $x',
1011         code    => '$x = !undef',
1012     },
1013     'expr::arith::not_PL_no' => {
1014         desc    => '!($x == $y) (using PL_sv_no)',
1015         setup   => 'my ($x, $y) = (1,2); my $z;',
1016         code    => '$z = !($x == $y)',
1017     },
1018     'expr::arith::not_PL_zero' => {
1019         desc    => '!%h (using PL_sv_zero)',
1020         setup   => 'my ($x, %h)',
1021         code    => '$x = !%h',
1022     },
1023     'expr::arith::not_PL_yes' => {
1024         desc    => '!($x == $y) (using PL_sv_yes)',
1025         setup   => 'my ($x, $y) = (1,1); my $z;',
1026         code    => '$z = !($x == $y)',
1027     },
1028     'expr::arith::not_undef' => {
1029         desc    => '!$y where $y is undef',
1030         setup   => 'my ($x, $y)',
1031         code    => '$x = !$y',
1032     },
1033     'expr::arith::not_0' => {
1034         desc    => '!$x where $x is 0',
1035         setup   => 'my ($x, $y) = (0, 0)',
1036         code    => '$y = !$x',
1037     },
1038     'expr::arith::not_1' => {
1039         desc    => '!$x where $x is 1',
1040         setup   => 'my ($x, $y) = (1, 0)',
1041         code    => '$y = !$x',
1042     },
1043     'expr::arith::not_string' => {
1044         desc    => '!$x where $x is "foo"',
1045         setup   => 'my ($x, $y) = ("foo", 0)',
1046         code    => '$y = !$x',
1047     },
1048     'expr::arith::not_ref' => {
1049         desc    => '!$x where $s is an array ref',
1050         setup   => 'my ($x, $y) = ([], 0)',
1051         code    => '$y = !$x',
1052     },
1053
1054     'expr::arith::preinc' => {
1055         desc    => '++$x',
1056         setup   => 'my $x = 1;',
1057         code    => '++$x',
1058     },
1059     'expr::arith::predec' => {
1060         desc    => '--$x',
1061         setup   => 'my $x = 1;',
1062         code    => '--$x',
1063     },
1064     'expr::arith::postinc' => {
1065         desc    => '$x++',
1066         setup   => 'my $x = 1; my $y',
1067         code    => '$y = $x++', # scalar context so not optimised to ++$x
1068     },
1069     'expr::arith::postdec' => {
1070         desc    => '$x--',
1071         setup   => 'my $x = 1; my $y',
1072         code    => '$y = $x--', # scalar context so not optimised to --$x
1073     },
1074
1075
1076
1077     # scalar assign, OP_SASSIGN
1078    
1079
1080     'expr::sassign::scalar_lex_int' => {
1081         desc    => 'lexical $x = 1',
1082         setup   => 'my $x',
1083         code    => '$x = 1',
1084     },
1085     'expr::sassign::scalar_lex_str' => {
1086         desc    => 'lexical $x = "abc"',
1087         setup   => 'my $x',
1088         code    => '$x = "abc"',
1089     },
1090     'expr::sassign::scalar_lex_strint' => {
1091         desc    => 'lexical $x = 1 where $x was previously a string',
1092         setup   => 'my $x = "abc"',
1093         code    => '$x = 1',
1094     },
1095     'expr::sassign::scalar_lex_intstr' => {
1096         desc    => 'lexical $x = "abc" where $x was previously an int',
1097         setup   => 'my $x = 1;',
1098         code    => '$x = "abc"',
1099     },
1100     'expr::sassign::lex_rv' => {
1101         desc    => 'lexical $ref1 = $ref2;',
1102         setup   => 'my $r1 = []; my $r = $r1;',
1103         code    => '$r = $r1;',
1104     },
1105     'expr::sassign::lex_rv1' => {
1106         desc    => 'lexical $ref1 = $ref2; where $$ref1 gets freed',
1107         setup   => 'my $r1 = []; my $r',
1108         code    => '$r = []; $r = $r1;',
1109     },
1110
1111
1112     'func::grep::bool0' => {
1113         desc    => 'grep returning 0 items in boolean context',
1114         setup   => 'my @a;',
1115         code    => '!grep $_, @a;',
1116     },
1117     'func::grep::bool1' => {
1118         desc    => 'grep returning 1 item in boolean context',
1119         setup   => 'my @a =(1);',
1120         code    => '!grep $_, @a;',
1121     },
1122     'func::grep::scalar0' => {
1123         desc    => 'returning 0 items in scalar context',
1124         setup   => 'my $g; my @a;',
1125         code    => '$g = grep $_, @a;',
1126     },
1127     'func::grep::scalar1' => {
1128         desc    => 'returning 1 item in scalar context',
1129         setup   => 'my $g; my @a =(1);',
1130         code    => '$g = grep $_, @a;',
1131     },
1132
1133     # (index() == -1) and variants optimise away the op_const and op_eq
1134     # and any assignment to a lexical var
1135     'func::index::bool' => {
1136         desc    => '(index() == -1) for match',
1137         setup   => 'my $x = "aaaab"',
1138         code    => 'index($x, "b") == -1',
1139     },
1140     'func::index::bool_fail' => {
1141         desc    => '(index() == -1) for no match',
1142         setup   => 'my $x = "aaaab"',
1143         code    => 'index($x, "c") == -1',
1144     },
1145     'func::index::lex_bool' => {
1146         desc    => '$lex = (index() == -1) for match',
1147         setup   => 'my $r; my $x = "aaaab"',
1148         code    => '$r = index($x, "b") == -1',
1149     },
1150     'func::index::lex_bool_fail' => {
1151         desc    => '$lex = (index() == -1) for no match',
1152         setup   => 'my $r; my $x = "aaaab"',
1153         code    => '$r = index($x, "c") == -1',
1154     },
1155
1156     # using a const string as second arg to index triggers using FBM.
1157     # the FBM matcher special-cases 1,2-byte strings.
1158     #
1159     'func::index::short_const1' => {
1160         desc    => 'index of a short string against a 1 char const substr',
1161         setup   => 'my $x = "aaaab"',
1162         code    => 'index $x, "b"',
1163     },
1164     'func::index::long_const1' => {
1165         desc    => 'index of a long string against a 1 char const substr',
1166         setup   => 'my $x = "a" x 1000 . "b"',
1167         code    => 'index $x, "b"',
1168     },
1169     'func::index::short_const2aabc_bc' => {
1170         desc    => 'index of a short string against a 2 char const substr',
1171         setup   => 'my $x = "aaaabc"',
1172         code    => 'index $x, "bc"',
1173     },
1174     'func::index::long_const2aabc_bc' => {
1175         desc    => 'index of a long string against a 2 char const substr',
1176         setup   => 'my $x = "a" x 1000 . "bc"',
1177         code    => 'index $x, "bc"',
1178     },
1179     'func::index::long_const2aa_ab' => {
1180         desc    => 'index of a long string aaa.. against const substr "ab"',
1181         setup   => 'my $x = "a" x 1000',
1182         code    => 'index $x, "ab"',
1183     },
1184     'func::index::long_const2bb_ab' => {
1185         desc    => 'index of a long string bbb.. against const substr "ab"',
1186         setup   => 'my $x = "b" x 1000',
1187         code    => 'index $x, "ab"',
1188     },
1189     'func::index::long_const2aa_bb' => {
1190         desc    => 'index of a long string aaa.. against const substr "bb"',
1191         setup   => 'my $x = "a" x 1000',
1192         code    => 'index $x, "bb"',
1193     },
1194     # this one is designed to be pathological
1195     'func::index::long_const2ab_aa' => {
1196         desc    => 'index of a long string abab.. against const substr "aa"',
1197         setup   => 'my $x = "ab" x 500',
1198         code    => 'index $x, "aa"',
1199     },
1200     # near misses with gaps, 1st letter
1201     'func::index::long_const2aaxx_xy' => {
1202         desc    => 'index of a long string with "xx"s against const substr "xy"',
1203         setup   => 'my $x = "aaaaaaaaxx" x 100',
1204         code    => 'index $x, "xy"',
1205     },
1206     # near misses with gaps, 2nd letter
1207     'func::index::long_const2aayy_xy' => {
1208         desc    => 'index of a long string with "yy"s against const substr "xy"',
1209         setup   => 'my $x = "aaaaaaaayy" x 100',
1210         code    => 'index $x, "xy"',
1211     },
1212     # near misses with gaps, duplicate letter
1213     'func::index::long_const2aaxy_xx' => {
1214         desc    => 'index of a long string with "xy"s against const substr "xx"',
1215         setup   => 'my $x = "aaaaaaaaxy" x 100',
1216         code    => 'index $x, "xx"',
1217     },
1218     # alternating near misses with gaps
1219     'func::index::long_const2aaxxaayy_xy' => {
1220         desc    => 'index of a long string with "xx/yy"s against const substr "xy"',
1221         setup   => 'my $x = "aaaaaaaaxxbbbbbbbbyy" x 50',
1222         code    => 'index $x, "xy"',
1223     },
1224     'func::index::short_const3aabcd_bcd' => {
1225         desc    => 'index of a short string against a 3 char const substr',
1226         setup   => 'my $x = "aaaabcd"',
1227         code    => 'index $x, "bcd"',
1228     },
1229     'func::index::long_const3aabcd_bcd' => {
1230         desc    => 'index of a long string against a 3 char const substr',
1231         setup   => 'my $x = "a" x 1000 . "bcd"',
1232         code    => 'index $x, "bcd"',
1233     },
1234     'func::index::long_const3ab_abc' => {
1235         desc    => 'index of a long string of "ab"s against a 3 char const substr "abc"',
1236         setup   => 'my $x = "ab" x 500',
1237         code    => 'index $x, "abc"',
1238     },
1239     'func::index::long_const3bc_abc' => {
1240         desc    => 'index of a long string of "bc"s against a 3 char const substr "abc"',
1241         setup   => 'my $x = "bc" x 500',
1242         code    => 'index $x, "abc"',
1243     },
1244     'func::index::utf8_position_1' => {
1245         desc    => 'index of a utf8 string, matching at position 1',
1246         setup   => 'my $x = "abc". chr(0x100); chop $x',
1247         code    => 'index $x, "b"',
1248     },
1249
1250
1251     'func::keys::lex::void_cxt_empty' => {
1252         desc    => ' keys() on an empty lexical hash in void context',
1253         setup   => 'my %h = ()',
1254         code    => 'keys %h',
1255     },
1256     'func::keys::lex::void_cxt' => {
1257         desc    => ' keys() on a non-empty lexical hash in void context',
1258         setup   => 'my %h = qw(aardvark 1 banana 2 cucumber 3)',
1259         code    => 'keys %h',
1260     },
1261     'func::keys::lex::bool_cxt_empty' => {
1262         desc    => ' keys() on an empty lexical hash in bool context',
1263         setup   => 'my %h = ()',
1264         code    => '!keys %h',
1265     },
1266     'func::keys::lex::bool_cxt' => {
1267         desc    => ' keys() on a non-empty lexical hash in bool context',
1268         setup   => 'my %h = qw(aardvark 1 banana 2 cucumber 3)',
1269         code    => '!keys %h',
1270     },
1271     'func::keys::lex::scalar_cxt_empty' => {
1272         desc    => ' keys() on an empty lexical hash in scalar context',
1273         setup   => 'my $k; my %h = ()',
1274         code    => '$k = keys %h',
1275     },
1276     'func::keys::lex::scalar_cxt' => {
1277         desc    => ' keys() on a non-empty lexical hash in scalar context',
1278         setup   => 'my $k; my %h = qw(aardvark 1 banana 2 cucumber 3)',
1279         code    => '$k = keys %h',
1280     },
1281     'func::keys::lex::list_cxt_empty' => {
1282         desc    => ' keys() on an empty lexical hash in list context',
1283         setup   => 'my %h = ()',
1284         code    => '() = keys %h',
1285     },
1286     'func::keys::lex::list_cxt' => {
1287         desc    => ' keys() on a non-empty lexical hash in list context',
1288         setup   => 'my %h = qw(aardvark 1 banana 2 cucumber 3)',
1289         code    => '() = keys %h',
1290     },
1291
1292     'func::keys::pkg::void_cxt_empty' => {
1293         desc    => ' keys() on an empty package hash in void context',
1294         setup   => 'our %h = ()',
1295         code    => 'keys %h',
1296     },
1297     'func::keys::pkg::void_cxt' => {
1298         desc    => ' keys() on a non-empty package hash in void context',
1299         setup   => 'our %h = qw(aardvark 1 banana 2 cucumber 3)',
1300         code    => 'keys %h',
1301     },
1302     'func::keys::pkg::bool_cxt_empty' => {
1303         desc    => ' keys() on an empty package hash in bool context',
1304         setup   => 'our %h = ()',
1305         code    => '!keys %h',
1306     },
1307     'func::keys::pkg::bool_cxt' => {
1308         desc    => ' keys() on a non-empty package hash in bool context',
1309         setup   => 'our %h = qw(aardvark 1 banana 2 cucumber 3)',
1310         code    => '!keys %h',
1311     },
1312     'func::keys::pkg::scalar_cxt_empty' => {
1313         desc    => ' keys() on an empty package hash in scalar context',
1314         setup   => 'my $k; our %h = ()',
1315         code    => '$k = keys %h',
1316     },
1317     'func::keys::pkg::scalar_cxt' => {
1318         desc    => ' keys() on a non-empty package hash in scalar context',
1319         setup   => 'my $k; our %h = qw(aardvark 1 banana 2 cucumber 3)',
1320         code    => '$k = keys %h',
1321     },
1322     'func::keys::pkg::list_cxt_empty' => {
1323         desc    => ' keys() on an empty package hash in list context',
1324         setup   => 'our %h = ()',
1325         code    => '() = keys %h',
1326     },
1327     'func::keys::pkg::list_cxt' => {
1328         desc    => ' keys() on a non-empty package hash in list context',
1329         setup   => 'our %h = qw(aardvark 1 banana 2 cucumber 3)',
1330         code    => '() = keys %h',
1331     },
1332
1333
1334     'func::length::bool0' => {
1335         desc    => 'length==0 in boolean context',
1336         setup   => 'my $s = "";',
1337         code    => '!length($s);',
1338     },
1339     'func::length::bool10' => {
1340         desc    => 'length==10 in boolean context',
1341         setup   => 'my $s = "abcdefghijk";',
1342         code    => '!length($s);',
1343     },
1344     'func::length::scalar10' => {
1345         desc    => 'length==10 in scalar context',
1346         setup   => 'my $p; my $s = "abcdefghijk";',
1347         code    => '$p = length($s);',
1348     },
1349     'func::length::bool0_utf8' => {
1350         desc    => 'utf8 string length==0 in boolean context',
1351         setup   => 'my $s = "\x{100}"; chop $s;',
1352         code    => '!length($s);',
1353     },
1354     'func::length::bool10_utf8' => {
1355         desc    => 'utf8 string length==10 in boolean context',
1356         setup   => 'my $s = "abcdefghij\x{100}";',
1357         code    => '!length($s);',
1358     },
1359     'func::length::scalar10_utf8' => {
1360         desc    => 'utf8 string length==10 in scalar context',
1361         setup   => 'my $p; my $s = "abcdefghij\x{100}";',
1362         code    => '$p = length($s);',
1363     },
1364
1365     'func::pos::bool0' => {
1366         desc    => 'pos==0 in boolean context',
1367         setup   => 'my $s = "abc"; pos($s) = 0',
1368         code    => '!pos($s);',
1369     },
1370     'func::pos::bool10' => {
1371         desc    => 'pos==10 in boolean context',
1372         setup   => 'my $s = "abcdefghijk"; pos($s) = 10',
1373         code    => '!pos($s);',
1374     },
1375     'func::pos::scalar10' => {
1376         desc    => 'pos==10 in scalar context',
1377         setup   => 'my $p; my $s = "abcdefghijk"; pos($s) = 10',
1378         code    => '$p = pos($s);',
1379     },
1380
1381     'func::ref::notaref_bool' => {
1382         desc    => 'ref($notaref) in boolean context',
1383         setup   => 'my $r = "boo"',
1384         code    => '!ref $r',
1385     },
1386     'func::ref::ref_bool' => {
1387         desc    => 'ref($ref) in boolean context',
1388         setup   => 'my $r = []',
1389         code    => '!ref $r',
1390     },
1391     'func::ref::blessedref_bool' => {
1392         desc    => 'ref($blessed_ref) in boolean context',
1393         setup   => 'my $r = bless []',
1394         code    => '!ref $r',
1395     },
1396
1397     'func::ref::notaref' => {
1398         desc    => 'ref($notaref) in scalar context',
1399         setup   => 'my $x; my $r = "boo"',
1400         code    => '$x = ref $r',
1401     },
1402     'func::ref::ref' => {
1403         desc    => 'ref($ref) in scalar context',
1404         setup   => 'my $x; my $r = []',
1405         code    => '$x = ref $r',
1406     },
1407     'func::ref::blessedref' => {
1408         desc    => 'ref($blessed_ref) in scalar context',
1409         setup   => 'my $x; my $r = bless []',
1410         code    => '$x = ref $r',
1411     },
1412
1413
1414
1415     'func::sort::num' => {
1416         desc    => 'plain numeric sort',
1417         setup   => 'my (@a, @b); @a = reverse 1..10;',
1418         code    => '@b = sort { $a <=> $b } @a',
1419     },
1420     'func::sort::num_block' => {
1421         desc    => 'codeblock numeric sort',
1422         setup   => 'my (@a, @b); @a = reverse 1..10;',
1423         code    => '@b = sort { $a + 1 <=> $b + 1 } @a',
1424     },
1425     'func::sort::num_fn' => {
1426         desc    => 'function numeric sort',
1427         setup   => 'sub f { $a + 1 <=> $b + 1 } my (@a, @b); @a = reverse 1..10;',
1428         code    => '@b = sort f @a',
1429     },
1430     'func::sort::str' => {
1431         desc    => 'plain string sort',
1432         setup   => 'my (@a, @b); @a = reverse "a".."j";',
1433         code    => '@b = sort { $a cmp $b } @a',
1434     },
1435     'func::sort::str_block' => {
1436         desc    => 'codeblock string sort',
1437         setup   => 'my (@a, @b); @a = reverse "a".."j";',
1438         code    => '@b = sort { ($a . "") cmp ($b . "") } @a',
1439     },
1440     'func::sort::str_fn' => {
1441         desc    => 'function string sort',
1442         setup   => 'sub f { ($a . "") cmp ($b . "") } my (@a, @b); @a = reverse  "a".."j";',
1443         code    => '@b = sort f @a',
1444     },
1445
1446     'func::sort::num_inplace' => {
1447         desc    => 'plain numeric sort in-place',
1448         setup   => 'my @a = reverse 1..10;',
1449         code    => '@a = sort { $a <=> $b } @a',
1450     },
1451     'func::sort::num_block_inplace' => {
1452         desc    => 'codeblock numeric sort in-place',
1453         setup   => 'my @a = reverse 1..10;',
1454         code    => '@a = sort { $a + 1 <=> $b + 1 } @a',
1455     },
1456     'func::sort::num_fn_inplace' => {
1457         desc    => 'function numeric sort in-place',
1458         setup   => 'sub f { $a + 1 <=> $b + 1 } my @a = reverse 1..10;',
1459         code    => '@a = sort f @a',
1460     },
1461     'func::sort::str_inplace' => {
1462         desc    => 'plain string sort in-place',
1463         setup   => 'my @a = reverse "a".."j";',
1464         code    => '@a = sort { $a cmp $b } @a',
1465     },
1466     'func::sort::str_block_inplace' => {
1467         desc    => 'codeblock string sort in-place',
1468         setup   => 'my @a = reverse "a".."j";',
1469         code    => '@a = sort { ($a . "") cmp ($b . "") } @a',
1470     },
1471     'func::sort::str_fn_inplace' => {
1472         desc    => 'function string sort in-place',
1473         setup   => 'sub f { ($a . "") cmp ($b . "") } my @a = reverse  "a".."j";',
1474         code    => '@a = sort f @a',
1475     },
1476
1477
1478     'func::split::vars' => {
1479         desc    => 'split into two lexical vars',
1480         setup   => 'my $s = "abc:def";',
1481         code    => 'my ($x, $y) = split /:/, $s, 2;',
1482     },
1483
1484     'func::split::array' => {
1485         desc    => 'split into a lexical array',
1486         setup   => 'my @a; my $s = "abc:def";',
1487         code    => '@a = split /:/, $s, 2;',
1488     },
1489     'func::split::myarray' => {
1490         desc    => 'split into a lexical array declared in the assign',
1491         setup   => 'my $s = "abc:def";',
1492         code    => 'my @a = split /:/, $s, 2;',
1493     },
1494     'func::split::arrayexpr' => {
1495         desc    => 'split into an @{$expr} ',
1496         setup   => 'my $s = "abc:def"; my $r = []',
1497         code    => '@$r = split /:/, $s, 2;',
1498     },
1499     'func::split::arraylist' => {
1500         desc    => 'split into an array with extra arg',
1501         setup   => 'my @a; my $s = "abc:def";',
1502         code    => '@a = (split(/:/, $s, 2), 1);',
1503     },
1504
1505
1506     'func::sprintf::d' => {
1507         desc    => '%d',
1508         setup   => 'my $s; my $a1 = 1234;',
1509         code    => '$s = sprintf "%d", $a1',
1510     },
1511     'func::sprintf::d8' => {
1512         desc    => '%8d',
1513         setup   => 'my $s; my $a1 = 1234;',
1514         code    => '$s = sprintf "%8d", $a1',
1515     },
1516     'func::sprintf::foo_d8' => {
1517         desc    => 'foo=%8d',
1518         setup   => 'my $s; my $a1 = 1234;',
1519         code    => '$s = sprintf "foo=%8d", $a1',
1520     },
1521
1522     'func::sprintf::f0' => {
1523         # "%.0f" is very special-cased
1524         desc    => 'sprintf "%.0f"',
1525         setup   => 'my $s; my $a1 = 123.456;',
1526         code    => '$s = sprintf "%.0f", $a1',
1527     },
1528     'func::sprintf::foo_f0' => {
1529         # "...%.0f..." is special-cased
1530         desc    => 'sprintf "foo=%.0f"',
1531         setup   => 'my $s; my $a1 = 123.456;',
1532         code    => '$s = sprintf "foo=%.0f\n", $a1',
1533     },
1534     'func::sprintf::foo_f93' => {
1535         desc    => 'foo=%9.3f',
1536         setup   => 'my $s; my $a1 = 123.456;',
1537         code    => '$s = sprintf "foo=%9.3f\n", $a1',
1538     },
1539
1540     'func::sprintf::g9' => {
1541         # "...%.NNNg..." is special-cased
1542         desc    => '%.9g',
1543         setup   => 'my $s; my $a1 = 123.456;',
1544         code    => '$s = sprintf "%.9g", $a1',
1545     },
1546     'func::sprintf::foo_g9' => {
1547         # "...%.NNNg..." is special-cased
1548         desc    => 'foo=%.9g',
1549         setup   => 'my $s; my $a1 = 123.456;',
1550         code    => '$s = sprintf "foo=%.9g\n", $a1',
1551     },
1552     'func::sprintf::foo_g93' => {
1553         desc    => 'foo=%9.3g',
1554         setup   => 'my $s; my $a1 = 123.456;',
1555         code    => '$s = sprintf "foo=%9.3g\n", $a1',
1556     },
1557
1558     'func::sprintf::s' => {
1559         desc    => '%s',
1560         setup   => 'my $s; my $a1 = "abcd";',
1561         code    => '$s = sprintf "%s", $a1',
1562     },
1563     'func::sprintf::foo_s' => {
1564         desc    => 'foo=%s',
1565         setup   => 'my $s; my $a1 = "abcd";',
1566         code    => '$s = sprintf "foo=%s", $a1',
1567     },
1568     'func::sprintf::mixed_utf8_s' => {
1569         desc    => 'foo=%s bar=%s baz=%s',
1570         setup   => 'my $s;',
1571         code    => '$s = sprintf "foo=%s", "ab\x{100}cd", "efg", "h\x{101}ij"',
1572     },
1573
1574     'func::subst::bool' => {
1575         desc    => 's/// in boolean context',
1576         setup   => '',
1577         code    => '$_ = "aaa"; !s/./x/g;'
1578     },
1579
1580
1581     'func::values::scalar_cxt_empty' => {
1582         desc    => ' values() on an empty hash in scalar context',
1583         setup   => 'my $k; my %h = ()',
1584         code    => '$k = values %h',
1585     },
1586     'func::values::scalar_cxt' => {
1587         desc    => ' values() on a non-empty hash in scalar context',
1588         setup   => 'my $k; my %h = qw(aardvark 1 banana 2 cucumber 3)',
1589         code    => '$k = values %h',
1590     },
1591     'func::values::list_cxt_empty' => {
1592         desc    => ' values() on an empty hash in list context',
1593         setup   => 'my %h = ()',
1594         code    => '() = values %h',
1595     },
1596     'func::values::list_cxt' => {
1597         desc    => ' values() on a non-empty hash in list context',
1598         setup   => 'my %h = qw(aardvark 1 banana 2 cucumber 3)',
1599         code    => '() = values %h',
1600     },
1601
1602
1603
1604     'loop::block' => {
1605         desc    => 'empty basic loop',
1606         setup   => '',
1607         code    => '{1;}',
1608     },
1609
1610     'loop::do' => {
1611         desc    => 'basic do block',
1612         setup   => 'my $x; my $y = 2;',
1613         code    => '$x = do {1; $y}', # the ';' stops the do being optimised
1614     },
1615
1616     'loop::for::my_range1' => {
1617         desc    => 'empty for loop with my var and 1 integer range',
1618         setup   => '',
1619         code    => 'for my $x (1..1) {}',
1620     },
1621     'loop::for::lex_range1' => {
1622         desc    => 'empty for loop with lexical var and 1 integer range',
1623         setup   => 'my $x;',
1624         code    => 'for $x (1..1) {}',
1625     },
1626     'loop::for::pkg_range1' => {
1627         desc    => 'empty for loop with package var and 1 integer range',
1628         setup   => '$x = 1;',
1629         code    => 'for $x (1..1) {}',
1630     },
1631     'loop::for::defsv_range1' => {
1632         desc    => 'empty for loop with $_ and integer 1 range',
1633         setup   => ';',
1634         code    => 'for (1..1) {}',
1635     },
1636     'loop::for::my_range4' => {
1637         desc    => 'empty for loop with my var and 4 integer range',
1638         setup   => '',
1639         code    => 'for my $x (1..4) {}',
1640     },
1641     'loop::for::lex_range4' => {
1642         desc    => 'empty for loop with lexical var and 4 integer range',
1643         setup   => 'my $x;',
1644         code    => 'for $x (1..4) {}',
1645     },
1646     'loop::for::pkg_range4' => {
1647         desc    => 'empty for loop with package var and 4 integer range',
1648         setup   => '$x = 1;',
1649         code    => 'for $x (1..4) {}',
1650     },
1651     'loop::for::defsv_range4' => {
1652         desc    => 'empty for loop with $_ and integer 4 range',
1653         setup   => ';',
1654         code    => 'for (1..4) {}',
1655     },
1656
1657     'loop::for::my_list1' => {
1658         desc    => 'empty for loop with my var and 1 integer list',
1659         setup   => '',
1660         code    => 'for my $x (1) {}',
1661     },
1662     'loop::for::lex_list1' => {
1663         desc    => 'empty for loop with lexical var and 1 integer list',
1664         setup   => 'my $x;',
1665         code    => 'for $x (1) {}',
1666     },
1667     'loop::for::pkg_list1' => {
1668         desc    => 'empty for loop with package var and 1 integer list',
1669         setup   => '$x = 1;',
1670         code    => 'for $x (1) {}',
1671     },
1672     'loop::for::defsv_list1' => {
1673         desc    => 'empty for loop with $_ and integer 1 list',
1674         setup   => ';',
1675         code    => 'for (1) {}',
1676     },
1677     'loop::for::my_list4' => {
1678         desc    => 'empty for loop with my var and 4 integer list',
1679         setup   => '',
1680         code    => 'for my $x (1,2,3,4) {}',
1681     },
1682     'loop::for::lex_list4' => {
1683         desc    => 'empty for loop with lexical var and 4 integer list',
1684         setup   => 'my $x;',
1685         code    => 'for $x (1,2,3,4) {}',
1686     },
1687     'loop::for::pkg_list4' => {
1688         desc    => 'empty for loop with package var and 4 integer list',
1689         setup   => '$x = 1;',
1690         code    => 'for $x (1,2,3,4) {}',
1691     },
1692     'loop::for::defsv_list4' => {
1693         desc    => 'empty for loop with $_ and integer 4 list',
1694         setup   => '',
1695         code    => 'for (1,2,3,4) {}',
1696     },
1697
1698     'loop::for::my_array1' => {
1699         desc    => 'empty for loop with my var and 1 integer array',
1700         setup   => 'my @a = (1);',
1701         code    => 'for my $x (@a) {}',
1702     },
1703     'loop::for::lex_array1' => {
1704         desc    => 'empty for loop with lexical var and 1 integer array',
1705         setup   => 'my $x; my @a = (1);',
1706         code    => 'for $x (@a) {}',
1707     },
1708     'loop::for::pkg_array1' => {
1709         desc    => 'empty for loop with package var and 1 integer array',
1710         setup   => '$x = 1; my @a = (1);',
1711         code    => 'for $x (@a) {}',
1712     },
1713     'loop::for::defsv_array1' => {
1714         desc    => 'empty for loop with $_ and integer 1 array',
1715         setup   => 'my @a = (@a);',
1716         code    => 'for (1) {}',
1717     },
1718     'loop::for::my_array4' => {
1719         desc    => 'empty for loop with my var and 4 integer array',
1720         setup   => 'my @a = (1..4);',
1721         code    => 'for my $x (@a) {}',
1722     },
1723     'loop::for::lex_array4' => {
1724         desc    => 'empty for loop with lexical var and 4 integer array',
1725         setup   => 'my $x; my @a = (1..4);',
1726         code    => 'for $x (@a) {}',
1727     },
1728     'loop::for::pkg_array4' => {
1729         desc    => 'empty for loop with package var and 4 integer array',
1730         setup   => '$x = 1; my @a = (1..4);',
1731         code    => 'for $x (@a) {}',
1732     },
1733     'loop::for::defsv_array4' => {
1734         desc    => 'empty for loop with $_ and integer 4 array',
1735         setup   => 'my @a = (1..4);',
1736         code    => 'for (@a) {}',
1737     },
1738
1739     'loop::for::next4' => {
1740         desc    => 'for loop containing only next with my var and integer 4 array',
1741         setup   => 'my @a = (1..4);',
1742         code    => 'for my $x (@a) {next}',
1743     },
1744
1745     'loop::grep::expr_3int' => {
1746         desc    => 'grep $_ > 0, 1,2,3',
1747         setup   => 'my @a',
1748         code    => '@a = grep $_ > 0, 1,2,3',
1749     },
1750
1751     'loop::grep::block_3int' => {
1752         desc    => 'grep { 1; $_ > 0} 1,2,3',
1753         setup   => 'my @a',
1754         code    => '@a = grep { 1; $_ > 0} 1,2,3',
1755     },
1756
1757     'loop::map::expr_3int' => {
1758         desc    => 'map $_+1, 1,2,3',
1759         setup   => 'my @a',
1760         code    => '@a = map $_+1, 1,2,3',
1761     },
1762
1763     'loop::map::block_3int' => {
1764         desc    => 'map { 1; $_+1} 1,2,3',
1765         setup   => 'my @a',
1766         code    => '@a = map { 1; $_+1} 1,2,3',
1767     },
1768
1769     'loop::while::i1' => {
1770         desc    => 'empty while loop 1 iteration',
1771         setup   => 'my $i = 0;',
1772         code    => 'while (++$i % 2) {}',
1773     },
1774     'loop::while::i4' => {
1775         desc    => 'empty while loop 4 iterations',
1776         setup   => 'my $i = 0;',
1777         code    => 'while (++$i % 4) {}',
1778     },
1779
1780
1781     'regex::anyof_plus::anchored' => {
1782         desc    => '/^[acgt]+/',
1783         setup   => '$_ = "a" x 100;',
1784         code    => '/^[acgt]+/',
1785     },
1786     'regex::anyof_plus::floating' => {
1787         desc    => '/[acgt]+where match starts at position 0 for 100 chars/',
1788         setup   => '$_ = "a" x 100;',
1789         code    => '/[acgt]+/',
1790     },
1791     'regex::anyof_plus::floating_away' => {
1792         desc    => '/[acgt]+/ where match starts at position 100 for 100 chars',
1793         setup   => '$_ = ("0" x 100) . ("a" x 100);',
1794         code    => '/[acgt]+/',
1795     },
1796
1797     'regex::whilem::min_captures_fail' => {
1798         desc    => '/WHILEM with anon-greedy match and captures that fails',
1799         setup   => '$_ = ("a" x 20)',
1800         code    => '/^(?:(.)(.))*?[XY]/',
1801     },
1802     'regex::whilem::max_captures_fail' => {
1803         desc    => '/WHILEM with a greedy match and captures that fails',
1804         setup   => '$_ = ("a" x 20)',
1805         code    => '/^(?:(.)(.))*[XY]/',
1806     },
1807 ];