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\\)');