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