This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
e4ccbf589dab532a929852eaec0c1383f2a5fb2f
[perl5.git] / ext / Devel-Peek / t / Peek.t
1 #!./perl -T
2
3 BEGIN {
4     require Config; import Config;
5     if ($Config{'extensions'} !~ /\bDevel\/Peek\b/) {
6         print "1..0 # Skip: Devel::Peek was not built\n";
7         exit 0;
8     }
9 }
10
11 BEGIN { require "../../t/test.pl"; }
12
13 use Devel::Peek;
14
15 plan(52);
16
17 our $DEBUG = 0;
18 open(SAVERR, ">&STDERR") or die "Can't dup STDERR: $!";
19
20 # If I reference any lexicals in this, I get the entire outer subroutine (or
21 # MAIN) dumped too, which isn't really what I want, as it's a lot of faff to
22 # maintain that.
23 format PIE =
24 Pie     @<<<<<
25 $::type
26 Good    @>>>>>
27 $::mmmm
28 .
29
30 sub do_test {
31     my $todo = $_[3];
32     my $repeat_todo = $_[4];
33     my $pattern = $_[2];
34     if (open(OUT,">peek$$")) {
35         open(STDERR, ">&OUT") or die "Can't dup OUT: $!";
36         Dump($_[1]);
37         print STDERR "*****\n";
38         Dump($_[1]); # second dump to compare with the first to make sure nothing changed.
39         open(STDERR, ">&SAVERR") or die "Can't restore STDERR: $!";
40         close(OUT);
41         if (open(IN, "peek$$")) {
42             local $/;
43             $pattern =~ s/\$ADDR/0x[[:xdigit:]]+/g;
44             $pattern =~ s/\$FLOAT/(?:\\d*\\.\\d+(?:e[-+]\\d+)?|\\d+)/g;
45             # handle DEBUG_LEAKING_SCALARS prefix
46             $pattern =~ s/^(\s*)(SV =.* at )/(?:$1ALLOCATED at .*?\n)?$1$2/mg;
47
48             # Need some clear generic mechanism to eliminate (or add) lines
49             # of dump output dependant on perl version. The (previous) use of
50             # things like $IVNV gave the illusion that the string passed in was
51             # a regexp into which variables were interpolated, but this wasn't
52             # actually true as those 'variables' actually also ate the
53             # whitspace on the line. So it seems better to mark lines that
54             # need to be eliminated. I considered (?# ... ) and (?{ ... }),
55             # but whilst embedded code or comment syntax would keep it as a
56             # legitimate regexp, it still isn't true. Seems easier and clearer
57             # things that look like comments.
58
59             # Could do this is in a s///mge but seems clearer like this:
60             $pattern = join '', map {
61                 # If we identify the version condition, take *it* out whatever
62                 s/\s*# (\$] [<>]=? 5\.\d\d\d)$//
63                     ? (eval $1 ? $_ : '')
64                     : $_ # Didn't match, so this line is in
65             } split /^/, $pattern;
66             
67             $pattern =~ s/\$PADMY/
68                 ($] < 5.009) ? 'PADBUSY,PADMY' : 'PADMY';
69             /mge;
70             $pattern =~ s/\$PADTMP/
71                 ($] < 5.009) ? 'PADBUSY,PADTMP' : 'PADTMP';
72             /mge;
73             $pattern =~ s/\$RV/
74                 ($] < 5.011) ? 'RV' : 'IV';
75             /mge;
76
77             print $pattern, "\n" if $DEBUG;
78             my ($dump, $dump2) = split m/\*\*\*\*\*\n/, scalar <IN>;
79             print $dump, "\n"    if $DEBUG;
80             like( $dump, qr/\A$pattern\Z/ms );
81
82             local $TODO = $repeat_todo;
83             is($dump2, $dump);
84
85             close(IN);
86
87             return $1;
88         } else {
89             die "$0: failed to open peek$$: !\n";
90         }
91     } else {
92         die "$0: failed to create peek$$: $!\n";
93     }
94 }
95
96 our   $a;
97 our   $b;
98 my    $c;
99 local $d = 0;
100
101 END {
102     1 while unlink("peek$$");
103 }
104
105 do_test( 1,
106         $a = "foo",
107 'SV = PV\\($ADDR\\) at $ADDR
108   REFCNT = 1
109   FLAGS = \\(POK,pPOK\\)
110   PV = $ADDR "foo"\\\0
111   CUR = 3
112   LEN = \\d+'
113        );
114
115 do_test( 2,
116         "bar",
117 'SV = PV\\($ADDR\\) at $ADDR
118   REFCNT = 1
119   FLAGS = \\(.*POK,READONLY,pPOK\\)
120   PV = $ADDR "bar"\\\0
121   CUR = 3
122   LEN = \\d+');
123
124 do_test( 3,
125         $b = 123,
126 'SV = IV\\($ADDR\\) at $ADDR
127   REFCNT = 1
128   FLAGS = \\(IOK,pIOK\\)
129   IV = 123');
130
131 do_test( 4,
132         456,
133 'SV = IV\\($ADDR\\) at $ADDR
134   REFCNT = 1
135   FLAGS = \\(.*IOK,READONLY,pIOK\\)
136   IV = 456');
137
138 do_test( 5,
139         $c = 456,
140 'SV = IV\\($ADDR\\) at $ADDR
141   REFCNT = 1
142   FLAGS = \\($PADMY,IOK,pIOK\\)
143   IV = 456');
144
145 # If perl is built with PERL_PRESERVE_IVUV then maths is done as integers
146 # where possible and this scalar will be an IV. If NO_PERL_PRESERVE_IVUV then
147 # maths is done in floating point always, and this scalar will be an NV.
148 # ([NI]) captures the type, referred to by \1 in this regexp and $type for
149 # building subsequent regexps.
150 my $type = do_test( 6,
151         $c + $d,
152 'SV = ([NI])V\\($ADDR\\) at $ADDR
153   REFCNT = 1
154   FLAGS = \\(PADTMP,\1OK,p\1OK\\)
155   \1V = 456');
156
157 ($d = "789") += 0.1;
158
159 do_test( 7,
160        $d,
161 'SV = PVNV\\($ADDR\\) at $ADDR
162   REFCNT = 1
163   FLAGS = \\(NOK,pNOK\\)
164   IV = \d+
165   NV = 789\\.(?:1(?:000+\d+)?|0999+\d+)
166   PV = $ADDR "789"\\\0
167   CUR = 3
168   LEN = \\d+');
169
170 do_test( 8,
171         0xabcd,
172 'SV = IV\\($ADDR\\) at $ADDR
173   REFCNT = 1
174   FLAGS = \\(.*IOK,READONLY,pIOK\\)
175   IV = 43981');
176
177 do_test( 9,
178         undef,
179 'SV = NULL\\(0x0\\) at $ADDR
180   REFCNT = 1
181   FLAGS = \\(\\)');
182
183 do_test(10,
184         \$a,
185 'SV = $RV\\($ADDR\\) at $ADDR
186   REFCNT = 1
187   FLAGS = \\(ROK\\)
188   RV = $ADDR
189   SV = PV\\($ADDR\\) at $ADDR
190     REFCNT = 2
191     FLAGS = \\(POK,pPOK\\)
192     PV = $ADDR "foo"\\\0
193     CUR = 3
194     LEN = \\d+');
195
196 my $c_pattern;
197 if ($type eq 'N') {
198   $c_pattern = '
199     SV = PVNV\\($ADDR\\) at $ADDR
200       REFCNT = 1
201       FLAGS = \\(IOK,NOK,pIOK,pNOK\\)
202       IV = 456
203       NV = 456
204       PV = 0';
205 } else {
206   $c_pattern = '
207     SV = IV\\($ADDR\\) at $ADDR
208       REFCNT = 1
209       FLAGS = \\(IOK,pIOK\\)
210       IV = 456';
211 }
212 do_test(11,
213        [$b,$c],
214 'SV = $RV\\($ADDR\\) at $ADDR
215   REFCNT = 1
216   FLAGS = \\(ROK\\)
217   RV = $ADDR
218   SV = PVAV\\($ADDR\\) at $ADDR
219     REFCNT = 1
220     FLAGS = \\(\\)
221     IV = 0                                      # $] < 5.009
222     NV = 0                                      # $] < 5.009
223     ARRAY = $ADDR
224     FILL = 1
225     MAX = 1
226     ARYLEN = 0x0
227     FLAGS = \\(REAL\\)
228     Elt No. 0
229     SV = IV\\($ADDR\\) at $ADDR
230       REFCNT = 1
231       FLAGS = \\(IOK,pIOK\\)
232       IV = 123
233     Elt No. 1' . $c_pattern);
234
235 do_test(12,
236        {$b=>$c},
237 'SV = $RV\\($ADDR\\) at $ADDR
238   REFCNT = 1
239   FLAGS = \\(ROK\\)
240   RV = $ADDR
241   SV = PVHV\\($ADDR\\) at $ADDR
242     REFCNT = 1
243     FLAGS = \\(SHAREKEYS\\)
244     IV = 1                                      # $] < 5.009
245     NV = $FLOAT                                 # $] < 5.009
246     ARRAY = $ADDR  \\(0:7, 1:1\\)
247     hash quality = 100.0%
248     KEYS = 1
249     FILL = 1
250     MAX = 7
251     RITER = -1
252     EITER = 0x0
253     Elt "123" HASH = $ADDR' . $c_pattern,
254         '',
255         $] > 5.009 && 'The hash iterator used in dump.c sets the OOK flag');
256
257 do_test(13,
258         sub(){@_},
259 'SV = $RV\\($ADDR\\) at $ADDR
260   REFCNT = 1
261   FLAGS = \\(ROK\\)
262   RV = $ADDR
263   SV = PVCV\\($ADDR\\) at $ADDR
264     REFCNT = 2
265     FLAGS = \\($PADMY,POK,pPOK,ANON,WEAKOUTSIDE\\)
266     IV = 0                                      # $] < 5.009
267     NV = 0                                      # $] < 5.009
268     PROTOTYPE = ""
269     COMP_STASH = $ADDR\\t"main"
270     START = $ADDR ===> \\d+
271     ROOT = $ADDR
272     XSUB = 0x0                                  # $] < 5.009
273     XSUBANY = 0                                 # $] < 5.009
274     GVGV::GV = $ADDR\\t"main" :: "__ANON__[^"]*"
275     FILE = ".*\\b(?i:peek\\.t)"
276     DEPTH = 0(?:
277     MUTEXP = $ADDR
278     OWNER = $ADDR)?
279     FLAGS = 0x404                               # $] < 5.009
280     FLAGS = 0x90                                # $] >= 5.009
281     OUTSIDE_SEQ = \\d+
282     PADLIST = $ADDR
283     PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
284     OUTSIDE = $ADDR \\(MAIN\\)');
285
286 do_test(14,
287         \&do_test,
288 'SV = $RV\\($ADDR\\) at $ADDR
289   REFCNT = 1
290   FLAGS = \\(ROK\\)
291   RV = $ADDR
292   SV = PVCV\\($ADDR\\) at $ADDR
293     REFCNT = (3|4)
294     FLAGS = \\(\\)
295     IV = 0                                      # $] < 5.009
296     NV = 0                                      # $] < 5.009
297     COMP_STASH = $ADDR\\t"main"
298     START = $ADDR ===> \\d+
299     ROOT = $ADDR
300     XSUB = 0x0                                  # $] < 5.009
301     XSUBANY = 0                                 # $] < 5.009
302     GVGV::GV = $ADDR\\t"main" :: "do_test"
303     FILE = ".*\\b(?i:peek\\.t)"
304     DEPTH = 1
305 (?:    MUTEXP = $ADDR
306     OWNER = $ADDR
307 )?    FLAGS = 0x0
308     OUTSIDE_SEQ = \\d+
309     PADLIST = $ADDR
310     PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
311        \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$todo"
312        \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$repeat_todo"
313        \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$pattern"
314       \\d+\\. $ADDR<\\d+> FAKE "\\$DEBUG"                       # $] < 5.009
315       \\d+\\. $ADDR<\\d+> FAKE "\\$DEBUG" flags=0x0 index=0     # $] >= 5.009
316       \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$dump"
317       \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$dump2"
318     OUTSIDE = $ADDR \\(MAIN\\)');
319
320 if ($] >= 5.011) {
321 do_test(15,
322         qr(tic),
323 'SV = $RV\\($ADDR\\) at $ADDR
324   REFCNT = 1
325   FLAGS = \\(ROK\\)
326   RV = $ADDR
327   SV = REGEXP\\($ADDR\\) at $ADDR
328     REFCNT = 1
329     FLAGS = \\(OBJECT,POK,FAKE,pPOK\\)
330     PV = $ADDR "\\(\\?-xism:tic\\)"
331     CUR = 12
332     LEN = 0
333     STASH = $ADDR\\t"Regexp"');
334 } else {
335 do_test(15,
336         qr(tic),
337 'SV = $RV\\($ADDR\\) at $ADDR
338   REFCNT = 1
339   FLAGS = \\(ROK\\)
340   RV = $ADDR
341   SV = PVMG\\($ADDR\\) at $ADDR
342     REFCNT = 1
343     FLAGS = \\(OBJECT,SMG\\)
344     IV = 0
345     NV = 0
346     PV = 0
347     MAGIC = $ADDR
348       MG_VIRTUAL = $ADDR
349       MG_TYPE = PERL_MAGIC_qr\(r\)
350       MG_OBJ = $ADDR
351         PAT = "\(\?-xism:tic\)"                 # $] >= 5.009
352         REFCNT = 2                              # $] >= 5.009
353     STASH = $ADDR\\t"Regexp"');
354 }
355
356 do_test(16,
357         (bless {}, "Tac"),
358 'SV = $RV\\($ADDR\\) at $ADDR
359   REFCNT = 1
360   FLAGS = \\(ROK\\)
361   RV = $ADDR
362   SV = PVHV\\($ADDR\\) at $ADDR
363     REFCNT = 1
364     FLAGS = \\(OBJECT,SHAREKEYS\\)
365     IV = 0                                      # $] < 5.009
366     NV = 0                                      # $] < 5.009
367     STASH = $ADDR\\t"Tac"
368     ARRAY = 0x0
369     KEYS = 0
370     FILL = 0
371     MAX = 7
372     RITER = -1
373     EITER = 0x0', '',
374         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
375         : "Something causes the HV's array to become allocated");
376
377 do_test(17,
378         *a,
379 'SV = PVGV\\($ADDR\\) at $ADDR
380   REFCNT = 5
381   FLAGS = \\(MULTI(?:,IN_PAD)?\\)               # $] >= 5.009
382   FLAGS = \\(GMG,SMG,MULTI(?:,IN_PAD)?\\)       # $] < 5.009
383   IV = 0                                        # $] < 5.009
384   NV = 0                                        # $] < 5.009
385   PV = 0                                        # $] < 5.009
386   MAGIC = $ADDR                                 # $] < 5.009
387     MG_VIRTUAL = &PL_vtbl_glob                  # $] < 5.009
388     MG_TYPE = PERL_MAGIC_glob\(\*\)             # $] < 5.009
389     MG_OBJ = $ADDR                              # $] < 5.009
390   NAME = "a"
391   NAMELEN = 1
392   GvSTASH = $ADDR\\t"main"
393   GP = $ADDR
394     SV = $ADDR
395     REFCNT = 1
396     IO = 0x0
397     FORM = 0x0  
398     AV = 0x0
399     HV = 0x0
400     CV = 0x0
401     CVGEN = 0x0
402     GPFLAGS = 0x0                               # $] < 5.009
403     LINE = \\d+
404     FILE = ".*\\b(?i:peek\\.t)"
405     FLAGS = $ADDR
406     EGV = $ADDR\\t"a"');
407
408 if (ord('A') == 193) {
409 do_test(18,
410         chr(256).chr(0).chr(512),
411 'SV = PV\\($ADDR\\) at $ADDR
412   REFCNT = 1
413   FLAGS = \\((?:$PADTMP,)?POK,READONLY,pPOK,UTF8\\)
414   PV = $ADDR "\\\214\\\101\\\0\\\235\\\101"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
415   CUR = 5
416   LEN = \\d+');
417 } else {
418 do_test(18,
419         chr(256).chr(0).chr(512),
420 'SV = PV\\($ADDR\\) at $ADDR
421   REFCNT = 1
422   FLAGS = \\((?:$PADTMP,)?POK,READONLY,pPOK,UTF8\\)
423   PV = $ADDR "\\\304\\\200\\\0\\\310\\\200"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
424   CUR = 5
425   LEN = \\d+');
426 }
427
428 if (ord('A') == 193) {
429 do_test(19,
430         {chr(256)=>chr(512)},
431 'SV = $RV\\($ADDR\\) at $ADDR
432   REFCNT = 1
433   FLAGS = \\(ROK\\)
434   RV = $ADDR
435   SV = PVHV\\($ADDR\\) at $ADDR
436     REFCNT = 1
437     FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
438     UV = 1                                      # $] < 5.009
439     NV = $FLOAT                                 # $] < 5.009
440     ARRAY = $ADDR  \\(0:7, 1:1\\)
441     hash quality = 100.0%
442     KEYS = 1
443     FILL = 1
444     MAX = 7
445     RITER = -1
446     EITER = $ADDR
447     Elt "\\\214\\\101" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
448     SV = PV\\($ADDR\\) at $ADDR
449       REFCNT = 1
450       FLAGS = \\(POK,pPOK,UTF8\\)
451       PV = $ADDR "\\\235\\\101"\\\0 \[UTF8 "\\\x\{200\}"\]
452       CUR = 2
453       LEN = \\d+',
454         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
455         : 'sv_length has been called on the element, and cached the result in MAGIC');
456 } else {
457 do_test(19,
458         {chr(256)=>chr(512)},
459 'SV = $RV\\($ADDR\\) at $ADDR
460   REFCNT = 1
461   FLAGS = \\(ROK\\)
462   RV = $ADDR
463   SV = PVHV\\($ADDR\\) at $ADDR
464     REFCNT = 1
465     FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
466     UV = 1                                      # $] < 5.009
467     NV = 0                                      # $] < 5.009
468     ARRAY = $ADDR  \\(0:7, 1:1\\)
469     hash quality = 100.0%
470     KEYS = 1
471     FILL = 1
472     MAX = 7
473     RITER = -1
474     EITER = $ADDR
475     Elt "\\\304\\\200" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
476     SV = PV\\($ADDR\\) at $ADDR
477       REFCNT = 1
478       FLAGS = \\(POK,pPOK,UTF8\\)
479       PV = $ADDR "\\\310\\\200"\\\0 \[UTF8 "\\\x\{200\}"\]
480       CUR = 2
481       LEN = \\d+', '',
482         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
483         : 'sv_length has been called on the element, and cached the result in MAGIC');
484 }
485
486 my $x="";
487 $x=~/.??/g;
488 do_test(20,
489         $x,
490 'SV = PVMG\\($ADDR\\) at $ADDR
491   REFCNT = 1
492   FLAGS = \\($PADMY,SMG,POK,pPOK\\)
493   IV = 0
494   NV = 0
495   PV = $ADDR ""\\\0
496   CUR = 0
497   LEN = \d+
498   MAGIC = $ADDR
499     MG_VIRTUAL = &PL_vtbl_mglob
500     MG_TYPE = PERL_MAGIC_regex_global\\(g\\)
501     MG_FLAGS = 0x01
502       MINMATCH');
503
504 #
505 # TAINTEDDIR is not set on: OS2, AMIGAOS, WIN32, MSDOS
506 # environment variables may be invisibly case-forced, hence the (?i:PATH)
507 # C<scalar(@ARGV)> is turned into an IV on VMS hence the (?:IV)?
508 # VMS is setting FAKE and READONLY flags.  What VMS uses for storing
509 # ENV hashes is also not always null terminated.
510 #
511 do_test(21,
512         $ENV{PATH}=@ARGV,  # scalar(@ARGV) is a handy known tainted value
513 'SV = PVMG\\($ADDR\\) at $ADDR
514   REFCNT = 1
515   FLAGS = \\(GMG,SMG,RMG,pIOK,pPOK\\)
516   IV = 0
517   NV = 0
518   PV = $ADDR "0"\\\0
519   CUR = 1
520   LEN = \d+
521   MAGIC = $ADDR
522     MG_VIRTUAL = &PL_vtbl_envelem
523     MG_TYPE = PERL_MAGIC_envelem\\(e\\)
524 (?:    MG_FLAGS = 0x01
525       TAINTEDDIR
526 )?    MG_LEN = -?\d+
527     MG_PTR = $ADDR (?:"(?i:PATH)"|=> HEf_SVKEY
528     SV = PV(?:IV)?\\($ADDR\\) at $ADDR
529       REFCNT = \d+
530       FLAGS = \\(TEMP,POK,(?:FAKE,READONLY,)?pPOK\\)
531 (?:      IV = 0
532 )?      PV = $ADDR "(?i:PATH)"(?:\\\0)?
533       CUR = \d+
534       LEN = \d+)
535   MAGIC = $ADDR
536     MG_VIRTUAL = &PL_vtbl_taint
537     MG_TYPE = PERL_MAGIC_taint\\(t\\)');
538
539 # blessed refs
540 do_test(22,
541         bless(\\undef, 'Foobar'),
542 'SV = $RV\\($ADDR\\) at $ADDR
543   REFCNT = 1
544   FLAGS = \\(ROK\\)
545   RV = $ADDR
546   SV = PVMG\\($ADDR\\) at $ADDR
547     REFCNT = 2
548     FLAGS = \\(OBJECT,ROK\\)
549     IV = -?\d+
550     NV = $FLOAT
551     RV = $ADDR
552     SV = NULL\\(0x0\\) at $ADDR
553       REFCNT = \d+
554       FLAGS = \\(READONLY\\)
555     PV = $ADDR ""
556     CUR = 0
557     LEN = 0
558     STASH = $ADDR\s+"Foobar"');
559
560 # Constant subroutines
561
562 sub const () {
563     "Perl rules";
564 }
565
566 do_test(23,
567         \&const,
568 'SV = $RV\\($ADDR\\) at $ADDR
569   REFCNT = 1
570   FLAGS = \\(ROK\\)
571   RV = $ADDR
572   SV = PVCV\\($ADDR\\) at $ADDR
573     REFCNT = (2)
574     FLAGS = \\(POK,pPOK,CONST\\)
575     IV = 0                                      # $] < 5.009
576     NV = 0                                      # $] < 5.009
577     PROTOTYPE = ""
578     COMP_STASH = 0x0
579     ROOT = 0x0                                  # $] < 5.009
580     XSUB = $ADDR
581     XSUBANY = $ADDR \\(CONST SV\\)
582     SV = PV\\($ADDR\\) at $ADDR
583       REFCNT = 1
584       FLAGS = \\(.*POK,READONLY,pPOK\\)
585       PV = $ADDR "Perl rules"\\\0
586       CUR = 10
587       LEN = \\d+
588     GVGV::GV = $ADDR\\t"main" :: "const"
589     FILE = ".*\\b(?i:peek\\.t)"
590     DEPTH = 0(?:
591     MUTEXP = $ADDR
592     OWNER = $ADDR)?
593     FLAGS = 0x200                               # $] < 5.009
594     FLAGS = 0xc00                               # $] >= 5.009
595     OUTSIDE_SEQ = 0
596     PADLIST = 0x0
597     OUTSIDE = 0x0 \\(null\\)'); 
598
599 # isUV should show on PVMG
600 do_test(24,
601         do { my $v = $1; $v = ~0; $v },
602 'SV = PVMG\\($ADDR\\) at $ADDR
603   REFCNT = 1
604   FLAGS = \\(IOK,pIOK,IsUV\\)
605   UV = \d+
606   NV = 0
607   PV = 0');
608
609 do_test(25,
610         *STDOUT{IO},
611 'SV = $RV\\($ADDR\\) at $ADDR
612   REFCNT = 1
613   FLAGS = \\(ROK\\)
614   RV = $ADDR
615   SV = PVIO\\($ADDR\\) at $ADDR
616     REFCNT = 3
617     FLAGS = \\(OBJECT\\)
618     IV = 0                                      # $] < 5.011
619     NV = 0                                      # $] < 5.011
620     STASH = $ADDR\s+"IO::File"
621     IFP = $ADDR
622     OFP = $ADDR
623     DIRP = 0x0
624     LINES = 0
625     PAGE = 0
626     PAGE_LEN = 60
627     LINES_LEFT = 0
628     TOP_GV = 0x0
629     FMT_GV = 0x0
630     BOTTOM_GV = 0x0
631     SUBPROCESS = 0                              # $] < 5.009
632     TYPE = \'>\'
633     FLAGS = 0x0');
634
635 do_test(26,
636         *PIE{FORMAT},
637 'SV = $RV\\($ADDR\\) at $ADDR
638   REFCNT = 1
639   FLAGS = \\(ROK\\)
640   RV = $ADDR
641   SV = PVFM\\($ADDR\\) at $ADDR
642     REFCNT = 2
643     FLAGS = \\(\\)
644     IV = 0                                      # $] < 5.009
645     NV = 0                                      # $] < 5.009
646 (?:    PV = 0
647 )?    COMP_STASH = 0x0
648     START = $ADDR ===> \\d+
649     ROOT = $ADDR
650     XSUB = 0x0                                  # $] < 5.009
651     XSUBANY = 0                                 # $] < 5.009
652     GVGV::GV = $ADDR\\t"main" :: "PIE"
653     FILE = ".*\\b(?i:peek\\.t)"
654 (?:    DEPTH = 0
655     MUTEXP = $ADDR
656     OWNER = $ADDR
657 )?    FLAGS = 0x0
658     OUTSIDE_SEQ = \\d+
659     LINES = 0
660     PADLIST = $ADDR
661     PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
662     OUTSIDE = $ADDR \\(MAIN\\)');