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