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