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