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 => 54;
  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\\)');
 666
 667 do_test(27,
 668         (bless {}, "\0::foo::\n::baz::\t::\0"),
 669 'SV = $RV\\($ADDR\\) at $ADDR
 670   REFCNT = 1
 671   FLAGS = \\(ROK\\)
 672   RV = $ADDR
 673   SV = PVHV\\($ADDR\\) at $ADDR
 674     REFCNT = 1
 675     FLAGS = \\(OBJECT,SHAREKEYS\\)
 676     IV = 0                                      # $] < 5.009
 677     NV = 0                                      # $] < 5.009
 678     STASH = $ADDR\\t"\\\\0::foo::\\\\n::baz::\\\\t::\\\\0"
 679     ARRAY = $ADDR
 680     KEYS = 0
 681     FILL = 0
 682     MAX = 7
 683     RITER = -1
 684     EITER = 0x0', '',
 685         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
 686         : "Something causes the HV's array to become allocated");
 687