[p5sagit/p5-mst-13.2.git] / ext / Devel / Peek / Peek.t

#!./perl -T

BEGIN {
    chdir 't' if -d 't';
    @INC = '../lib';
    require Config; import Config;
    if ($Config{'extensions'} !~ /\bPeek\b/) {
        print "1..0 # Skip: Devel::Peek was not built\n";
        exit 0;
    }
}

use Devel::Peek;

print "1..22\n";

our $DEBUG = 0;
open(SAVERR, ">&STDERR") or die "Can't dup STDERR: $!";

sub do_test {
    my $pattern = pop;
    if (open(OUT,">peek$$")) {
	open(STDERR, ">&OUT") or die "Can't dup OUT: $!";
	Dump($_[1]);
	open(STDERR, ">&SAVERR") or die "Can't restore STDERR: $!";
	close(OUT);
	if (open(IN, "peek$$")) {
	    local $/;
	    $pattern =~ s/\$ADDR/0x[[:xdigit:]]+/g;
	    $pattern =~ s/\$FLOAT/(?:\\d*\\.\\d+(?:e[-+]\\d+)?|\\d+)/g;
	    print $pattern, "\n" if $DEBUG;
	    my $dump = <IN>;
	    print $dump, "\n"    if $DEBUG;
	    print "[$dump] vs [$pattern]\nnot " unless $dump =~ /\A$pattern\Z/ms;
	    print "ok $_[0]\n";
	    close(IN);
            return $1;
	} else {
	    die "$0: failed to open peek$$: !\n";
	}
    } else {
	die "$0: failed to create peek$$: $!\n";
    }
}

our   $a;
our   $b;
my    $c;
local $d = 0;

do_test( 1,
	$a = "foo",
'SV = PV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(POK,pPOK\\)
  PV = $ADDR "foo"\\\0
  CUR = 3
  LEN = \\d+'
       );

do_test( 2,
        "bar",
'SV = PV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(.*POK,READONLY,pPOK\\)
  PV = $ADDR "bar"\\\0
  CUR = 3
  LEN = \\d+');

do_test( 3,
        $b = 123,
'SV = IV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(IOK,pIOK\\)
  IV = 123');

do_test( 4,
        456,
'SV = IV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(.*IOK,READONLY,pIOK\\)
  IV = 456');

do_test( 5,
        $c = 456,
'SV = IV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(PADBUSY,PADMY,IOK,pIOK\\)
  IV = 456');

# If perl is built with PERL_PRESERVE_IVUV then maths is done as integers
# where possible and this scalar will be an IV. If NO_PERL_PRESERVE_IVUV then
# maths is done in floating point always, and this scalar will be an NV.
# ([NI]) captures the type, referred to by \1 in this regexp and $type for
# building subsequent regexps.
my $type = do_test( 6,
        $c + $d,
'SV = ([NI])V\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(PADTMP,\1OK,p\1OK\\)
  \1V = 456');

($d = "789") += 0.1;

do_test( 7,
       $d,
'SV = PVNV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(NOK,pNOK\\)
  IV = 0
  NV = 789\\.(?:1(?:000+\d+)?|0999+\d+)
  PV = $ADDR "789"\\\0
  CUR = 3
  LEN = \\d+');

do_test( 8,
        0xabcd,
'SV = IV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(.*IOK,READONLY,pIOK\\)
  IV = 43981');

do_test( 9,
        undef,
'SV = NULL\\(0x0\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(\\)');

do_test(10,
        \$a,
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(POK,pPOK\\)
    PV = $ADDR "foo"\\\0
    CUR = 3
    LEN = \\d+');

my $c_pattern;
if ($type eq 'N') {
  $c_pattern = '
    SV = PVNV\\($ADDR\\) at $ADDR
      REFCNT = 1
      FLAGS = \\(IOK,NOK,pIOK,pNOK\\)
      IV = 456
      NV = 456
      PV = 0';
} else {
  $c_pattern = '
    SV = IV\\($ADDR\\) at $ADDR
      REFCNT = 1
      FLAGS = \\(IOK,pIOK\\)
      IV = 456';
}
do_test(11,
       [$b,$c],
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVAV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(\\)
    IV = 0
    NV = 0
    ARRAY = $ADDR
    FILL = 1
    MAX = 1
    ARYLEN = 0x0
    FLAGS = \\(REAL\\)
    Elt No. 0
    SV = IV\\($ADDR\\) at $ADDR
      REFCNT = 1
      FLAGS = \\(IOK,pIOK\\)
      IV = 123
    Elt No. 1' . $c_pattern);

do_test(12,
       {$b=>$c},
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVHV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(SHAREKEYS\\)
    IV = 1
    NV = $FLOAT
    ARRAY = $ADDR  \\(0:7, 1:1\\)
    hash quality = 100.0%
    KEYS = 1
    FILL = 1
    MAX = 7
    RITER = -1
    EITER = 0x0
    Elt "123" HASH = $ADDR' . $c_pattern);

do_test(13,
        sub(){@_},
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVCV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(PADBUSY,PADMY,POK,pPOK,ANON\\)
    IV = 0
    NV = 0
    PROTOTYPE = ""
    COMP_STASH = $ADDR\\t"main"
    START = $ADDR ===> \\d+
    ROOT = $ADDR
    XSUB = 0x0
    XSUBANY = 0
    GVGV::GV = $ADDR\\t"main" :: "__ANON__[^"]*"
    FILE = ".*\\b(?i:peek\\.t)"
    DEPTH = 0
(?:    MUTEXP = $ADDR
    OWNER = $ADDR
)?    FLAGS = 0x4
    OUTSIDE_SEQ = \\d+
    PADLIST = $ADDR
    PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
    OUTSIDE = $ADDR \\(MAIN\\)');

do_test(14,
        \&do_test,
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVCV\\($ADDR\\) at $ADDR
    REFCNT = (3|4)
    FLAGS = \\(\\)
    IV = 0
    NV = 0
    COMP_STASH = $ADDR\\t"main"
    START = $ADDR ===> \\d+
    ROOT = $ADDR
    XSUB = 0x0
    XSUBANY = 0
    GVGV::GV = $ADDR\\t"main" :: "do_test"
    FILE = ".*\\b(?i:peek\\.t)"
    DEPTH = 1
(?:    MUTEXP = $ADDR
    OWNER = $ADDR
)?    FLAGS = 0x0
    OUTSIDE_SEQ = \\d+
    PADLIST = $ADDR
    PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
       \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$pattern"
      \\d+\\. $ADDR<\\d+> FAKE "\\$DEBUG"
      \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$dump"
    OUTSIDE = $ADDR \\(MAIN\\)');

do_test(15,
        qr(tic),
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVMG\\($ADDR\\) at $ADDR
    REFCNT = 1
    FLAGS = \\(OBJECT,RMG\\)
    IV = 0
    NV = 0
    PV = 0
    MAGIC = $ADDR
      MG_VIRTUAL = $ADDR
      MG_TYPE = PERL_MAGIC_qr\(r\)
      MG_OBJ = $ADDR
    STASH = $ADDR\\t"Regexp"');

do_test(16,
        (bless {}, "Tac"),
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVHV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(OBJECT,SHAREKEYS\\)
    IV = 0
    NV = 0
    STASH = $ADDR\\t"Tac"
    ARRAY = 0x0
    KEYS = 0
    FILL = 0
    MAX = 7
    RITER = -1
    EITER = 0x0');

do_test(17,
	*a,
'SV = PVGV\\($ADDR\\) at $ADDR
  REFCNT = 5
  FLAGS = \\(GMG,SMG,MULTI(?:,IN_PAD)?\\)
  IV = 0
  NV = 0
  MAGIC = $ADDR
    MG_VIRTUAL = &PL_vtbl_glob
    MG_TYPE = PERL_MAGIC_glob\(\*\)
    MG_OBJ = $ADDR
  NAME = "a"
  NAMELEN = 1
  GvSTASH = $ADDR\\t"main"
  GP = $ADDR
    SV = $ADDR
    REFCNT = 1
    IO = 0x0
    FORM = 0x0  
    AV = 0x0
    HV = 0x0
    CV = 0x0
    CVGEN = 0x0
    GPFLAGS = 0x0
    LINE = \\d+
    FILE = ".*\\b(?i:peek\\.t)"
    FLAGS = $ADDR
    EGV = $ADDR\\t"a"');

if (ord('A') == 193) {
do_test(18,
	chr(256).chr(0).chr(512),
'SV = PV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\((?:PADBUSY,PADTMP,)?POK,READONLY,pPOK,UTF8\\)
  PV = $ADDR "\\\214\\\101\\\0\\\235\\\101"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
  CUR = 5
  LEN = \\d+');
} else {
do_test(18,
	chr(256).chr(0).chr(512),
'SV = PV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\((?:PADBUSY,PADTMP,)?POK,READONLY,pPOK,UTF8\\)
  PV = $ADDR "\\\304\\\200\\\0\\\310\\\200"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
  CUR = 5
  LEN = \\d+');
}

if (ord('A') == 193) {
do_test(19,
	{chr(256)=>chr(512)},
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVHV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
    UV = 1
    NV = $FLOAT
    ARRAY = $ADDR  \\(0:7, 1:1\\)
    hash quality = 100.0%
    KEYS = 1
    FILL = 1
    MAX = 7
    RITER = -1
    EITER = $ADDR
    Elt "\\\214\\\101" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
    SV = PV\\($ADDR\\) at $ADDR
      REFCNT = 1
      FLAGS = \\(POK,pPOK,UTF8\\)
      PV = $ADDR "\\\235\\\101"\\\0 \[UTF8 "\\\x\{200\}"\]
      CUR = 2
      LEN = \\d+');
} else {
do_test(19,
	{chr(256)=>chr(512)},
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVHV\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
    UV = 1
    NV = 0
    ARRAY = $ADDR  \\(0:7, 1:1\\)
    hash quality = 100.0%
    KEYS = 1
    FILL = 1
    MAX = 7
    RITER = -1
    EITER = $ADDR
    Elt "\\\304\\\200" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
    SV = PV\\($ADDR\\) at $ADDR
      REFCNT = 1
      FLAGS = \\(POK,pPOK,UTF8\\)
      PV = $ADDR "\\\310\\\200"\\\0 \[UTF8 "\\\x\{200\}"\]
      CUR = 2
      LEN = \\d+');
}

my $x="";
$x=~/.??/g;
do_test(20,
        $x,
'SV = PVMG\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(PADBUSY,PADMY,SMG,POK,pPOK\\)
  IV = 0
  NV = 0
  PV = $ADDR ""\\\0
  CUR = 0
  LEN = 1
  MAGIC = $ADDR
    MG_VIRTUAL = &PL_vtbl_mglob
    MG_TYPE = PERL_MAGIC_regex_global\\(g\\)
    MG_FLAGS = 0x01
      MINMATCH');

#
# TAINTEDDIR is not set on: OS2, AMIGAOS, WIN32, MSDOS
# environment variables may be invisibly case-forced, hence the (?i:PATH)
#
do_test(21,
        $ENV{PATH}=@ARGV,  # scalar(@ARGV) is a handy known tainted value
'SV = PVMG\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(GMG,SMG,RMG,pIOK,pPOK\\)
  IV = 0
  NV = 0
  PV = $ADDR "0"\\\0
  CUR = 1
  LEN = \d+
  MAGIC = $ADDR
    MG_VIRTUAL = &PL_vtbl_envelem
    MG_TYPE = PERL_MAGIC_envelem\\(e\\)
(?:    MG_FLAGS = 0x01
      TAINTEDDIR
)?    MG_LEN = 4
    MG_PTR = $ADDR "(?i:PATH)"
  MAGIC = $ADDR
    MG_VIRTUAL = &PL_vtbl_taint
    MG_TYPE = PERL_MAGIC_taint\\(t\\)');

END {
  1 while unlink("peek$$");
}

# blessed refs
do_test(22,
	bless(\\undef, 'Foobar'),
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVMG\\($ADDR\\) at $ADDR
    REFCNT = 2
    FLAGS = \\(OBJECT,ROK\\)
    IV = -?\d+
    NV = $FLOAT
    RV = $ADDR
    SV = NULL\\(0x0\\) at $ADDR
      REFCNT = \d+
      FLAGS = \\(READONLY\\)
    PV = $ADDR ""
    CUR = 0
    LEN = 0
    STASH = $ADDR\s+"Foobar"');
Commit	Line	Data
99331854	1	#!./perl -T
9ec58fb7	2
	3	BEGIN {
	4	chdir 't' if -d 't';
20822f61	5	@INC = '../lib';
9ec58fb7	6	require Config; import Config;
	7	if ($Config{'extensions'} !~ /\bPeek\b/) {
	8	print "1..0 # Skip: Devel::Peek was not built\n";
	9	exit 0;
	10	}
	11	}
	12
9248c45a	13	use Devel::Peek;
9248c45a	14
6bf47b08	15	print "1..22\n";
9248c45a	16
9248c45a	17	our $DEBUG = 0;
277ddfaf	18	open(SAVERR, ">&STDERR") or die "Can't dup STDERR: $!";
9248c45a	19
	20	sub do_test {
	21	my $pattern = pop;
277ddfaf	22	if (open(OUT,">peek$$")) {
277ddfaf	23	open(STDERR, ">&OUT") or die "Can't dup OUT: $!";
9248c45a	24	Dump($_[1]);
277ddfaf	25	open(STDERR, ">&SAVERR") or die "Can't restore STDERR: $!";
277ddfaf	26	close(OUT);
9248c45a	27	if (open(IN, "peek$$")) {
	28	local $/;
	29	$pattern =~ s/\$ADDR/0x[[:xdigit:]]+/g;
8aacddc1	30	$pattern =~ s/\$FLOAT/(?:\\d*\\.\\d+(?:e[-+]\\d+)?\|\\d+)/g;
9248c45a	31	print $pattern, "\n" if $DEBUG;
	32	my $dump = <IN>;
	33	print $dump, "\n" if $DEBUG;
99331854	34	print "[$dump] vs [$pattern]\nnot " unless $dump =~ /\A$pattern\Z/ms;
9248c45a	35	print "ok $_[0]\n";
9248c45a	36	close(IN);
59d8ce62	37	return $1;
9248c45a	38	} else {
	39	die "$0: failed to open peek$$: !\n";
	40	}
	41	} else {
	42	die "$0: failed to create peek$$: $!\n";
	43	}
	44	}
	45
	46	our $a;
	47	our $b;
	48	my $c;
208edb77	49	local $d = 0;
9248c45a	50
	51	do_test( 1,
	52	$a = "foo",
	53	'SV = PV\\($ADDR\\) at $ADDR
	54	REFCNT = 1
	55	FLAGS = \\(POK,pPOK\\)
	56	PV = $ADDR "foo"\\\0
	57	CUR = 3
1badabf5	58	LEN = \\d+'
9248c45a	59	);
	60
	61	do_test( 2,
	62	"bar",
	63	'SV = PV\\($ADDR\\) at $ADDR
	64	REFCNT = 1
7766e686	65	FLAGS = \\(.*POK,READONLY,pPOK\\)
9248c45a	66	PV = $ADDR "bar"\\\0
9248c45a	67	CUR = 3
1badabf5	68	LEN = \\d+');
9248c45a	69
	70	do_test( 3,
	71	$b = 123,
	72	'SV = IV\\($ADDR\\) at $ADDR
	73	REFCNT = 1
	74	FLAGS = \\(IOK,pIOK\\)
	75	IV = 123');
	76
	77	do_test( 4,
	78	456,
	79	'SV = IV\\($ADDR\\) at $ADDR
	80	REFCNT = 1
7766e686	81	FLAGS = \\(.*IOK,READONLY,pIOK\\)
9248c45a	82	IV = 456');
	83
	84	do_test( 5,
	85	$c = 456,
	86	'SV = IV\\($ADDR\\) at $ADDR
	87	REFCNT = 1
	88	FLAGS = \\(PADBUSY,PADMY,IOK,pIOK\\)
	89	IV = 456');
	90
59d8ce62	91	# If perl is built with PERL_PRESERVE_IVUV then maths is done as integers
	92	# where possible and this scalar will be an IV. If NO_PERL_PRESERVE_IVUV then
	93	# maths is done in floating point always, and this scalar will be an NV.
	94	# ([NI]) captures the type, referred to by \1 in this regexp and $type for
	95	# building subsequent regexps.
	96	my $type = do_test( 6,
9248c45a	97	$c + $d,
59d8ce62	98	'SV = ([NI])V\\($ADDR\\) at $ADDR
9248c45a	99	REFCNT = 1
59d8ce62	100	FLAGS = \\(PADTMP,\1OK,p\1OK\\)
59d8ce62	101	\1V = 456');
9248c45a	102
	103	($d = "789") += 0.1;
	104
	105	do_test( 7,
	106	$d,
	107	'SV = PVNV\\($ADDR\\) at $ADDR
	108	REFCNT = 1
	109	FLAGS = \\(NOK,pNOK\\)
	110	IV = 0
ac634a9a	111	NV = 789\\.(?:1(?:000+\d+)?\|0999+\d+)
9248c45a	112	PV = $ADDR "789"\\\0
9248c45a	113	CUR = 3
1badabf5	114	LEN = \\d+');
9248c45a	115
	116	do_test( 8,
	117	0xabcd,
	118	'SV = IV\\($ADDR\\) at $ADDR
	119	REFCNT = 1
28e5dec8	120	FLAGS = \\(.*IOK,READONLY,pIOK\\)
28e5dec8	121	IV = 43981');
9248c45a	122
	123	do_test( 9,
	124	undef,
	125	'SV = NULL\\(0x0\\) at $ADDR
	126	REFCNT = 1
	127	FLAGS = \\(\\)');
	128
	129	do_test(10,
	130	\$a,
	131	'SV = RV\\($ADDR\\) at $ADDR
	132	REFCNT = 1
	133	FLAGS = \\(ROK\\)
	134	RV = $ADDR
	135	SV = PV\\($ADDR\\) at $ADDR
	136	REFCNT = 2
	137	FLAGS = \\(POK,pPOK\\)
	138	PV = $ADDR "foo"\\\0
	139	CUR = 3
1badabf5	140	LEN = \\d+');
9248c45a	141
59d8ce62	142	my $c_pattern;
	143	if ($type eq 'N') {
	144	$c_pattern = '
	145	SV = PVNV\\($ADDR\\) at $ADDR
	146	REFCNT = 1
	147	FLAGS = \\(IOK,NOK,pIOK,pNOK\\)
	148	IV = 456
	149	NV = 456
	150	PV = 0';
	151	} else {
	152	$c_pattern = '
	153	SV = IV\\($ADDR\\) at $ADDR
	154	REFCNT = 1
	155	FLAGS = \\(IOK,pIOK\\)
	156	IV = 456';
	157	}
9248c45a	158	do_test(11,
	159	[$b,$c],
	160	'SV = RV\\($ADDR\\) at $ADDR
	161	REFCNT = 1
	162	FLAGS = \\(ROK\\)
	163	RV = $ADDR
	164	SV = PVAV\\($ADDR\\) at $ADDR
	165	REFCNT = 2
	166	FLAGS = \\(\\)
	167	IV = 0
	168	NV = 0
	169	ARRAY = $ADDR
	170	FILL = 1
	171	MAX = 1
	172	ARYLEN = 0x0
	173	FLAGS = \\(REAL\\)
	174	Elt No. 0
	175	SV = IV\\($ADDR\\) at $ADDR
	176	REFCNT = 1
	177	FLAGS = \\(IOK,pIOK\\)
	178	IV = 123
59d8ce62	179	Elt No. 1' . $c_pattern);
9248c45a	180
	181	do_test(12,
	182	{$b=>$c},
	183	'SV = RV\\($ADDR\\) at $ADDR
	184	REFCNT = 1
	185	FLAGS = \\(ROK\\)
	186	RV = $ADDR
	187	SV = PVHV\\($ADDR\\) at $ADDR
	188	REFCNT = 2
	189	FLAGS = \\(SHAREKEYS\\)
	190	IV = 1
8aacddc1	191	NV = $FLOAT
9248c45a	192	ARRAY = $ADDR \\(0:7, 1:1\\)
b8fa94d8	193	hash quality = 100.0%
9248c45a	194	KEYS = 1
	195	FILL = 1
	196	MAX = 7
	197	RITER = -1
	198	EITER = 0x0
59d8ce62	199	Elt "123" HASH = $ADDR' . $c_pattern);
9248c45a	200
	201	do_test(13,
	202	sub(){@_},
	203	'SV = RV\\($ADDR\\) at $ADDR
	204	REFCNT = 1
	205	FLAGS = \\(ROK\\)
	206	RV = $ADDR
	207	SV = PVCV\\($ADDR\\) at $ADDR
	208	REFCNT = 2
	209	FLAGS = \\(PADBUSY,PADMY,POK,pPOK,ANON\\)
	210	IV = 0
	211	NV = 0
	212	PROTOTYPE = ""
	213	COMP_STASH = $ADDR\\t"main"
	214	START = $ADDR ===> \\d+
	215	ROOT = $ADDR
	216	XSUB = 0x0
	217	XSUBANY = 0
208edb77	218	GVGV::GV = $ADDR\\t"main" :: "__ANON__[^"]*"
084d946d	219	FILE = ".*\\b(?i:peek\\.t)"
9248c45a	220	DEPTH = 0
9856a127	221	(?: MUTEXP = $ADDR
208edb77	222	OWNER = $ADDR
208edb77	223	)? FLAGS = 0x4
a3985cdc	224	OUTSIDE_SEQ = \\d+
9248c45a	225	PADLIST = $ADDR
dd2155a4	226	PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
9248c45a	227	OUTSIDE = $ADDR \\(MAIN\\)');
	228
	229	do_test(14,
	230	\&do_test,
	231	'SV = RV\\($ADDR\\) at $ADDR
	232	REFCNT = 1
	233	FLAGS = \\(ROK\\)
	234	RV = $ADDR
	235	SV = PVCV\\($ADDR\\) at $ADDR
9856a127	236	REFCNT = (3\|4)
9248c45a	237	FLAGS = \\(\\)
	238	IV = 0
	239	NV = 0
	240	COMP_STASH = $ADDR\\t"main"
	241	START = $ADDR ===> \\d+
	242	ROOT = $ADDR
	243	XSUB = 0x0
	244	XSUBANY = 0
	245	GVGV::GV = $ADDR\\t"main" :: "do_test"
084d946d	246	FILE = ".*\\b(?i:peek\\.t)"
9248c45a	247	DEPTH = 1
9856a127	248	(?: MUTEXP = $ADDR
208edb77	249	OWNER = $ADDR
208edb77	250	)? FLAGS = 0x0
a3985cdc	251	OUTSIDE_SEQ = \\d+
9248c45a	252	PADLIST = $ADDR
dd2155a4	253	PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
ee6cee0c	254	\\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$pattern"
	255	\\d+\\. $ADDR<\\d+> FAKE "\\$DEBUG"
	256	\\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$dump"
9248c45a	257	OUTSIDE = $ADDR \\(MAIN\\)');
	258
	259	do_test(15,
	260	qr(tic),
	261	'SV = RV\\($ADDR\\) at $ADDR
	262	REFCNT = 1
	263	FLAGS = \\(ROK\\)
	264	RV = $ADDR
	265	SV = PVMG\\($ADDR\\) at $ADDR
	266	REFCNT = 1
	267	FLAGS = \\(OBJECT,RMG\\)
	268	IV = 0
	269	NV = 0
	270	PV = 0
	271	MAGIC = $ADDR
	272	MG_VIRTUAL = $ADDR
14befaf4	273	MG_TYPE = PERL_MAGIC_qr\(r\)
9248c45a	274	MG_OBJ = $ADDR
	275	STASH = $ADDR\\t"Regexp"');
	276
	277	do_test(16,
	278	(bless {}, "Tac"),
	279	'SV = RV\\($ADDR\\) at $ADDR
	280	REFCNT = 1
	281	FLAGS = \\(ROK\\)
	282	RV = $ADDR
	283	SV = PVHV\\($ADDR\\) at $ADDR
	284	REFCNT = 2
	285	FLAGS = \\(OBJECT,SHAREKEYS\\)
	286	IV = 0
	287	NV = 0
	288	STASH = $ADDR\\t"Tac"
	289	ARRAY = 0x0
	290	KEYS = 0
	291	FILL = 0
	292	MAX = 7
	293	RITER = -1
	294	EITER = 0x0');
	295
	296	do_test(17,
	297	*a,
	298	'SV = PVGV\\($ADDR\\) at $ADDR
	299	REFCNT = 5
b07ccbd7	300	FLAGS = \\(GMG,SMG,MULTI(?:,IN_PAD)?\\)
9248c45a	301	IV = 0
	302	NV = 0
	303	MAGIC = $ADDR
	304	MG_VIRTUAL = &PL_vtbl_glob
14befaf4	305	MG_TYPE = PERL_MAGIC_glob\(\*\)
9248c45a	306	MG_OBJ = $ADDR
9248c45a	307	NAME = "a"
	308	NAMELEN = 1
	309	GvSTASH = $ADDR\\t"main"
	310	GP = $ADDR
	311	SV = $ADDR
	312	REFCNT = 1
	313	IO = 0x0
	314	FORM = 0x0
	315	AV = 0x0
	316	HV = 0x0
	317	CV = 0x0
	318	CVGEN = 0x0
	319	GPFLAGS = 0x0
9ec58fb7	320	LINE = \\d+
084d946d	321	FILE = ".*\\b(?i:peek\\.t)"
e39917cc	322	FLAGS = $ADDR
9248c45a	323	EGV = $ADDR\\t"a"');
9248c45a	324
cdb2dd7b	325	if (ord('A') == 193) {
	326	do_test(18,
	327	chr(256).chr(0).chr(512),
	328	'SV = PV\\($ADDR\\) at $ADDR
	329	REFCNT = 1
	330	FLAGS = \\((?:PADBUSY,PADTMP,)?POK,READONLY,pPOK,UTF8\\)
	331	PV = $ADDR "\\\214\\\101\\\0\\\235\\\101"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
	332	CUR = 5
1badabf5	333	LEN = \\d+');
cdb2dd7b	334	} else {
e6abe6d8	335	do_test(18,
	336	chr(256).chr(0).chr(512),
	337	'SV = PV\\($ADDR\\) at $ADDR
	338	REFCNT = 1
898eb500	339	FLAGS = \\((?:PADBUSY,PADTMP,)?POK,READONLY,pPOK,UTF8\\)
98c991d1	340	PV = $ADDR "\\\304\\\200\\\0\\\310\\\200"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
e6abe6d8	341	CUR = 5
1badabf5	342	LEN = \\d+');
cdb2dd7b	343	}
e6abe6d8	344
cdb2dd7b	345	if (ord('A') == 193) {
	346	do_test(19,
	347	{chr(256)=>chr(512)},
	348	'SV = RV\\($ADDR\\) at $ADDR
	349	REFCNT = 1
	350	FLAGS = \\(ROK\\)
	351	RV = $ADDR
	352	SV = PVHV\\($ADDR\\) at $ADDR
	353	REFCNT = 2
b2caaddd	354	FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
574c8022	355	UV = 1
8aacddc1	356	NV = $FLOAT
cdb2dd7b	357	ARRAY = $ADDR \\(0:7, 1:1\\)
	358	hash quality = 100.0%
	359	KEYS = 1
	360	FILL = 1
	361	MAX = 7
	362	RITER = -1
	363	EITER = $ADDR
6cbfa5b4	364	Elt "\\\214\\\101" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
cdb2dd7b	365	SV = PV\\($ADDR\\) at $ADDR
	366	REFCNT = 1
	367	FLAGS = \\(POK,pPOK,UTF8\\)
	368	PV = $ADDR "\\\235\\\101"\\\0 \[UTF8 "\\\x\{200\}"\]
	369	CUR = 2
1badabf5	370	LEN = \\d+');
cdb2dd7b	371	} else {
98c991d1	372	do_test(19,
	373	{chr(256)=>chr(512)},
	374	'SV = RV\\($ADDR\\) at $ADDR
	375	REFCNT = 1
	376	FLAGS = \\(ROK\\)
	377	RV = $ADDR
	378	SV = PVHV\\($ADDR\\) at $ADDR
	379	REFCNT = 2
19692e8d	380	FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
574c8022	381	UV = 1
98c991d1	382	NV = 0
	383	ARRAY = $ADDR \\(0:7, 1:1\\)
	384	hash quality = 100.0%
	385	KEYS = 1
	386	FILL = 1
	387	MAX = 7
	388	RITER = -1
	389	EITER = $ADDR
	390	Elt "\\\304\\\200" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
	391	SV = PV\\($ADDR\\) at $ADDR
	392	REFCNT = 1
	393	FLAGS = \\(POK,pPOK,UTF8\\)
	394	PV = $ADDR "\\\310\\\200"\\\0 \[UTF8 "\\\x\{200\}"\]
	395	CUR = 2
1badabf5	396	LEN = \\d+');
cdb2dd7b	397	}
98c991d1	398
99331854	399	my $x="";
	400	$x=~/.??/g;
	401	do_test(20,
	402	$x,
	403	'SV = PVMG\\($ADDR\\) at $ADDR
	404	REFCNT = 1
	405	FLAGS = \\(PADBUSY,PADMY,SMG,POK,pPOK\\)
	406	IV = 0
	407	NV = 0
	408	PV = $ADDR ""\\\0
	409	CUR = 0
	410	LEN = 1
	411	MAGIC = $ADDR
	412	MG_VIRTUAL = &PL_vtbl_mglob
	413	MG_TYPE = PERL_MAGIC_regex_global\\(g\\)
	414	MG_FLAGS = 0x01
	415	MINMATCH');
	416
f24fdb76	417	#
	418	# TAINTEDDIR is not set on: OS2, AMIGAOS, WIN32, MSDOS
	419	# environment variables may be invisibly case-forced, hence the (?i:PATH)
	420	#
99331854	421	do_test(21,
	422	$ENV{PATH}=@ARGV, # scalar(@ARGV) is a handy known tainted value
	423	'SV = PVMG\\($ADDR\\) at $ADDR
	424	REFCNT = 1
	425	FLAGS = \\(GMG,SMG,RMG,pIOK,pPOK\\)
	426	IV = 0
	427	NV = 0
	428	PV = $ADDR "0"\\\0
	429	CUR = 1
	430	LEN = \d+
	431	MAGIC = $ADDR
	432	MG_VIRTUAL = &PL_vtbl_envelem
	433	MG_TYPE = PERL_MAGIC_envelem\\(e\\)
d25a523c	434	(?: MG_FLAGS = 0x01
99331854	435	TAINTEDDIR
d25a523c	436	)? MG_LEN = 4
f24fdb76	437	MG_PTR = $ADDR "(?i:PATH)"
99331854	438	MAGIC = $ADDR
	439	MG_VIRTUAL = &PL_vtbl_taint
	440	MG_TYPE = PERL_MAGIC_taint\\(t\\)');
	441
9248c45a	442	END {
92e5451f	443	1 while unlink("peek$$");
9248c45a	444	}
6bf47b08	445
	446	# blessed refs
	447	do_test(22,
	448	bless(\\undef, 'Foobar'),
	449	'SV = RV\\($ADDR\\) at $ADDR
	450	REFCNT = 1
	451	FLAGS = \\(ROK\\)
	452	RV = $ADDR
	453	SV = PVMG\\($ADDR\\) at $ADDR
	454	REFCNT = 2
	455	FLAGS = \\(OBJECT,ROK\\)
7957ad98	456	IV = -?\d+
7957ad98	457	NV = $FLOAT
6bf47b08	458	RV = $ADDR
	459	SV = NULL\\(0x0\\) at $ADDR
	460	REFCNT = \d+
	461	FLAGS = \\(READONLY\\)
	462	PV = $ADDR ""
	463	CUR = 0
	464	LEN = 0
	465	STASH = $ADDR\s+"Foobar"');