[perl5.git] / ext / Devel / Peek / t / Peek.t

#!./perl -T

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

BEGIN { require "./test.pl"; }

use Devel::Peek;

plan(24);

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;
	    # handle DEBUG_LEAKING_SCALARS prefix
	    $pattern =~ s/^(\s*)(SV =.* at )/(?:$1ALLOCATED at .*?\n)?$1$2/mg;

	    $pattern =~ s/^ *\$XSUB *\n/
		($] < 5.009) ? "    XSUB = 0\n    XSUBANY = 0\n" : '';
	    /mge;
	    $pattern =~ s/^ *\$ROOT *\n/
		($] < 5.009) ? "    ROOT = 0x0\n" : '';
	    /mge;
	    $pattern =~ s/^ *\$IVNV *\n/
		($] < 5.009) ? "    IV = 0\n    NV = 0\n" : '';
	    /mge;

	    print $pattern, "\n" if $DEBUG;
	    my $dump = <IN>;
	    print $dump, "\n"    if $DEBUG;
	    like( $dump, qr/\A$pattern\Z/ms );
	    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;

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

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 = \\(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 = \d+
  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 = 1
    FLAGS = \\(\\)
    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 = 1
    FLAGS = \\(SHAREKEYS\\)
    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 = \\(PADMY,POK,pPOK,ANON,WEAKOUTSIDE\\)
    $IVNV
    PROTOTYPE = ""
    COMP_STASH = $ADDR\\t"main"
    START = $ADDR ===> \\d+
    ROOT = $ADDR
    $XSUB
    GVGV::GV = $ADDR\\t"main" :: "__ANON__[^"]*"
    FILE = ".*\\b(?i:peek\\.t)"
    DEPTH = 0
(?:    MUTEXP = $ADDR
    OWNER = $ADDR
)?    FLAGS = 0x90
    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 = \\(\\)
    $IVNV
    COMP_STASH = $ADDR\\t"main"
    START = $ADDR ===> \\d+
    ROOT = $ADDR
    $XSUB
    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" flags=0x0 index=0
      \\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,SMG\\)
    IV = 0
    NV = 0
    PV = 0
    MAGIC = $ADDR
      MG_VIRTUAL = $ADDR
      MG_TYPE = PERL_MAGIC_qr\(r\)
      MG_OBJ = $ADDR
        PAT = "\(\?-xism:tic\)"
        REFCNT = 2
    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 = 1
    FLAGS = \\(OBJECT,SHAREKEYS\\)
    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 = \\(MULTI(?:,IN_PAD)?\\)
  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
    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 = \\((?: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 = \\((?: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 = 1
    FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
    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 = 1
    FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
    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 = \\(PADMY,SMG,POK,pPOK\\)
  IV = 0
  NV = 0
  PV = $ADDR ""\\\0
  CUR = 0
  LEN = \d+
  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)
# C<scalar(@ARGV)> is turned into an IV on VMS hence the (?:IV)?
# VMS is setting FAKE and READONLY flags.  What VMS uses for storing
# ENV hashes is also not always null terminated.
#
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 = -?\d+
    MG_PTR = $ADDR (?:"(?i:PATH)"|=> HEf_SVKEY
    SV = PV(?:IV)?\\($ADDR\\) at $ADDR
      REFCNT = \d+
      FLAGS = \\(TEMP,POK,(?:FAKE,READONLY,)?pPOK\\)
(?:      IV = 0
)?      PV = $ADDR "(?i:PATH)"(?:\\\0)?
      CUR = \d+
      LEN = \d+)
  MAGIC = $ADDR
    MG_VIRTUAL = &PL_vtbl_taint
    MG_TYPE = PERL_MAGIC_taint\\(t\\)');

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

# Constant subroutines

sub const () {
    "Perl rules";
}

do_test(23,
	\&const,
'SV = RV\\($ADDR\\) at $ADDR
  REFCNT = 1
  FLAGS = \\(ROK\\)
  RV = $ADDR
  SV = PVCV\\($ADDR\\) at $ADDR
    REFCNT = (2)
    FLAGS = \\(POK,pPOK,CONST\\)
    $IVNV
    PROTOTYPE = ""
    COMP_STASH = 0x0
    $ROOT
    XSUB = $ADDR
    XSUBANY = $ADDR \\(CONST SV\\)
    SV = PV\\($ADDR\\) at $ADDR
      REFCNT = 1
      FLAGS = \\(.*POK,READONLY,pPOK\\)
      PV = $ADDR "Perl rules"\\\0
      CUR = 10
      LEN = \\d+
    GVGV::GV = $ADDR\\t"main" :: "const"
    FILE = ".*\\b(?i:peek\\.t)"
    DEPTH = 0
(?:    MUTEXP = $ADDR
    OWNER = $ADDR
)?    FLAGS = 0xc00
    OUTSIDE_SEQ = 0
    PADLIST = 0x0
    OUTSIDE = 0x0 \\(null\\)');	

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