[perl5.git] / t / lib / dumper.t

#!./perl -w
#
# testsuite for Data::Dumper
#

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

use Data::Dumper;
use Config;
my $Is_ebcdic = defined($Config{'ebcdic'}) && $Config{'ebcdic'} eq 'define';

$Data::Dumper::Pad = "#";
my $TMAX;
my $XS;
my $TNUM = 0;
my $WANT = '';

sub TEST {
  my $string = shift;
  my $t = eval $string;
  ++$TNUM;
  $t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
      if ($WANT =~ /deadbeef/);
  if ($Is_ebcdic) {
      # these data need massaging with non ascii character sets
      # because of hashing order differences
      $WANT = join("\n",sort(split(/\n/,$WANT)));
      $WANT =~ s/\,$//mg;
      $t    = join("\n",sort(split(/\n/,$t)));
      $t    =~ s/\,$//mg;
  }
  print( ($t eq $WANT and not $@) ? "ok $TNUM\n"
	: "not ok $TNUM\n--Expected--\n$WANT\n--Got--\n$@$t\n");

  ++$TNUM;
  eval "$t";
  print $@ ? "not ok $TNUM\n# \$@ says: $@\n" : "ok $TNUM\n";

  $t = eval $string;
  ++$TNUM;
  $t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
      if ($WANT =~ /deadbeef/);
  if ($Is_ebcdic) {
      # here too there are hashing order differences
      $WANT = join("\n",sort(split(/\n/,$WANT)));
      $WANT =~ s/\,$//mg;
      $t    = join("\n",sort(split(/\n/,$t)));
      $t    =~ s/\,$//mg;
  }
  print( ($t eq $WANT and not $@) ? "ok $TNUM\n"
	: "not ok $TNUM\n--Expected--\n$WANT\n--Got--\n$@$t\n");
}

if (defined &Data::Dumper::Dumpxs) {
  print "### XS extension loaded, will run XS tests\n";
  $TMAX = 186; $XS = 1;
}
else {
  print "### XS extensions not loaded, will NOT run XS tests\n";
  $TMAX = 93; $XS = 0;
}

print "1..$TMAX\n";

#############
#############

@c = ('c');
$c = \@c;
$b = {};
$a = [1, $b, $c];
$b->{a} = $a;
$b->{b} = $a->[1];
$b->{c} = $a->[2];

############# 1
##
$WANT = <<'EOT';
#$a = [
#       1,
#       {
#         'a' => $a,
#         'b' => $a->[1],
#         'c' => [
#                  'c'
#                ]
#       },
#       $a->[1]{'c'}
#     ];
#$b = $a->[1];
#$c = $a->[1]{'c'};
EOT

TEST q(Data::Dumper->Dump([$a,$b,$c], [qw(a b c)]));
TEST q(Data::Dumper->Dumpxs([$a,$b,$c], [qw(a b c)])) if $XS;


############# 7
##
$WANT = <<'EOT';
#@a = (
#       1,
#       {
#         'a' => [],
#         'b' => {},
#         'c' => [
#                  'c'
#                ]
#       },
#       []
#     );
#$a[1]{'a'} = \@a;
#$a[1]{'b'} = $a[1];
#$a[2] = $a[1]{'c'};
#$b = $a[1];
EOT

$Data::Dumper::Purity = 1;         # fill in the holes for eval
TEST q(Data::Dumper->Dump([$a, $b], [qw(*a b)])); # print as @a
TEST q(Data::Dumper->Dumpxs([$a, $b], [qw(*a b)])) if $XS;

############# 13
##
$WANT = <<'EOT';
#%b = (
#       'a' => [
#                1,
#                {},
#                [
#                  'c'
#                ]
#              ],
#       'b' => {},
#       'c' => []
#     );
#$b{'a'}[1] = \%b;
#$b{'b'} = \%b;
#$b{'c'} = $b{'a'}[2];
#$a = $b{'a'};
EOT

TEST q(Data::Dumper->Dump([$b, $a], [qw(*b a)])); # print as %b
TEST q(Data::Dumper->Dumpxs([$b, $a], [qw(*b a)])) if $XS;

############# 19
##
$WANT = <<'EOT';
#$a = [
#  1,
#  {
#    'a' => [],
#    'b' => {},
#    'c' => []
#  },
#  []
#];
#$a->[1]{'a'} = $a;
#$a->[1]{'b'} = $a->[1];
#$a->[1]{'c'} = \@c;
#$a->[2] = \@c;
#$b = $a->[1];
EOT

$Data::Dumper::Indent = 1;
TEST q(
       $d = Data::Dumper->new([$a,$b], [qw(a b)]);
       $d->Seen({'*c' => $c});
       $d->Dump;
      );
if ($XS) {
  TEST q(
	 $d = Data::Dumper->new([$a,$b], [qw(a b)]);
	 $d->Seen({'*c' => $c});
	 $d->Dumpxs;
	);
}


############# 25
##
$WANT = <<'EOT';
#$a = [
#       #0
#       1,
#       #1
#       {
#         a => $a,
#         b => $a->[1],
#         c => [
#                #0
#                'c'
#              ]
#       },
#       #2
#       $a->[1]{c}
#     ];
#$b = $a->[1];
EOT

$d->Indent(3);
$d->Purity(0)->Quotekeys(0);
TEST q( $d->Reset; $d->Dump );

TEST q( $d->Reset; $d->Dumpxs ) if $XS;

############# 31
##
$WANT = <<'EOT';
#$VAR1 = [
#  1,
#  {
#    'a' => [],
#    'b' => {},
#    'c' => [
#      'c'
#    ]
#  },
#  []
#];
#$VAR1->[1]{'a'} = $VAR1;
#$VAR1->[1]{'b'} = $VAR1->[1];
#$VAR1->[2] = $VAR1->[1]{'c'};
EOT

TEST q(Dumper($a));
TEST q(Data::Dumper::DumperX($a)) if $XS;

############# 37
##
$WANT = <<'EOT';
#[
#  1,
#  {
#    a => $VAR1,
#    b => $VAR1->[1],
#    c => [
#      'c'
#    ]
#  },
#  $VAR1->[1]{c}
#]
EOT

{
  local $Data::Dumper::Purity = 0;
  local $Data::Dumper::Quotekeys = 0;
  local $Data::Dumper::Terse = 1;
  TEST q(Dumper($a));
  TEST q(Data::Dumper::DumperX($a)) if $XS;
}


############# 43
##
$WANT = <<'EOT';
#$VAR1 = {
#  "abc\0'\efg" => "mno\0"
#};
EOT

$foo = { "abc\000\'\efg" => "mno\000" };
{
  local $Data::Dumper::Useqq = 1;
  TEST q(Dumper($foo));
}

  $WANT = <<"EOT";
#\$VAR1 = {
#  'abc\0\\'\efg' => 'mno\0'
#};
EOT

  {
    local $Data::Dumper::Useqq = 1;
    TEST q(Data::Dumper::DumperX($foo)) if $XS;   # cheat
  }


#############
#############

{
  package main;
  use Data::Dumper;
  $foo = 5;
  @foo = (-10,\*foo);
  %foo = (a=>1,b=>\$foo,c=>\@foo);
  $foo{d} = \%foo;
  $foo[2] = \%foo;

############# 49
##
  $WANT = <<'EOT';
#$foo = \*::foo;
#*::foo = \5;
#*::foo = [
#           #0
#           -10,
#           #1
#           do{my $o},
#           #2
#           {
#             'a' => 1,
#             'b' => do{my $o},
#             'c' => [],
#             'd' => {}
#           }
#         ];
#*::foo{ARRAY}->[1] = $foo;
#*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
#*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
#*::foo{ARRAY}->[2]{'d'} = *::foo{ARRAY}->[2];
#*::foo = *::foo{ARRAY}->[2];
#@bar = @{*::foo{ARRAY}};
#%baz = %{*::foo{ARRAY}->[2]};
EOT

  $Data::Dumper::Purity = 1;
  $Data::Dumper::Indent = 3;
  TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz']));
  TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz'])) if $XS;

############# 55
##
  $WANT = <<'EOT';
#$foo = \*::foo;
#*::foo = \5;
#*::foo = [
#  -10,
#  do{my $o},
#  {
#    'a' => 1,
#    'b' => do{my $o},
#    'c' => [],
#    'd' => {}
#  }
#];
#*::foo{ARRAY}->[1] = $foo;
#*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
#*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
#*::foo{ARRAY}->[2]{'d'} = *::foo{ARRAY}->[2];
#*::foo = *::foo{ARRAY}->[2];
#$bar = *::foo{ARRAY};
#$baz = *::foo{ARRAY}->[2];
EOT

  $Data::Dumper::Indent = 1;
  TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
  TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;

############# 61
##
  $WANT = <<'EOT';
#@bar = (
#  -10,
#  \*::foo,
#  {}
#);
#*::foo = \5;
#*::foo = \@bar;
#*::foo = {
#  'a' => 1,
#  'b' => do{my $o},
#  'c' => [],
#  'd' => {}
#};
#*::foo{HASH}->{'b'} = *::foo{SCALAR};
#*::foo{HASH}->{'c'} = \@bar;
#*::foo{HASH}->{'d'} = *::foo{HASH};
#$bar[2] = *::foo{HASH};
#%baz = %{*::foo{HASH}};
#$foo = $bar[1];
EOT

  TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\*foo], ['*bar', '*baz', '*foo']));
  TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\*foo], ['*bar', '*baz', '*foo'])) if $XS;

############# 67
##
  $WANT = <<'EOT';
#$bar = [
#  -10,
#  \*::foo,
#  {}
#];
#*::foo = \5;
#*::foo = $bar;
#*::foo = {
#  'a' => 1,
#  'b' => do{my $o},
#  'c' => [],
#  'd' => {}
#};
#*::foo{HASH}->{'b'} = *::foo{SCALAR};
#*::foo{HASH}->{'c'} = $bar;
#*::foo{HASH}->{'d'} = *::foo{HASH};
#$bar->[2] = *::foo{HASH};
#$baz = *::foo{HASH};
#$foo = $bar->[1];
EOT

  TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo']));
  TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo'])) if $XS;

############# 73
##
  $WANT = <<'EOT';
#$foo = \*::foo;
#@bar = (
#  -10,
#  $foo,
#  {
#    a => 1,
#    b => \5,
#    c => \@bar,
#    d => $bar[2]
#  }
#);
#%baz = %{$bar[2]};
EOT

  $Data::Dumper::Purity = 0;
  $Data::Dumper::Quotekeys = 0;
  TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz']));
  TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz'])) if $XS;

############# 79
##
  $WANT = <<'EOT';
#$foo = \*::foo;
#$bar = [
#  -10,
#  $foo,
#  {
#    a => 1,
#    b => \5,
#    c => $bar,
#    d => $bar->[2]
#  }
#];
#$baz = $bar->[2];
EOT

  TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
  TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;

}

#############
#############
{
  package main;
  @dogs = ( 'Fido', 'Wags' );
  %kennel = (
            First => \$dogs[0],
            Second =>  \$dogs[1],
           );
  $dogs[2] = \%kennel;
  $mutts = \%kennel;
  $mutts = $mutts;         # avoid warning
  
############# 85
##
  $WANT = <<'EOT';
#%kennels = (
#  First => \'Fido',
#  Second => \'Wags'
#);
#@dogs = (
#  ${$kennels{First}},
#  ${$kennels{Second}},
#  \%kennels
#);
#%mutts = %kennels;
EOT

  TEST q(
	 $d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
				[qw(*kennels *dogs *mutts)] );
	 $d->Dump;
	);
  if ($XS) {
    TEST q(
	   $d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
				  [qw(*kennels *dogs *mutts)] );
	   $d->Dumpxs;
	  );
  }
  
############# 91
##
  $WANT = <<'EOT';
#%kennels = %kennels;
#@dogs = @dogs;
#%mutts = %kennels;
EOT

  TEST q($d->Dump);
  TEST q($d->Dumpxs) if $XS;
  
############# 97
##
  $WANT = <<'EOT';
#%kennels = (
#  First => \'Fido',
#  Second => \'Wags'
#);
#@dogs = (
#  ${$kennels{First}},
#  ${$kennels{Second}},
#  \%kennels
#);
#%mutts = %kennels;
EOT

  
  TEST q($d->Reset; $d->Dump);
  if ($XS) {
    TEST q($d->Reset; $d->Dumpxs);
  }

############# 103
##
  $WANT = <<'EOT';
#@dogs = (
#  'Fido',
#  'Wags',
#  {
#    First => \$dogs[0],
#    Second => \$dogs[1]
#  }
#);
#%kennels = %{$dogs[2]};
#%mutts = %{$dogs[2]};
EOT

  TEST q(
	 $d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
				[qw(*dogs *kennels *mutts)] );
	 $d->Dump;
	);
  if ($XS) {
    TEST q(
	   $d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
				  [qw(*dogs *kennels *mutts)] );
	   $d->Dumpxs;
	  );
  }
  
############# 109
##
  TEST q($d->Reset->Dump);
  if ($XS) {
    TEST q($d->Reset->Dumpxs);
  }

############# 115
##
  $WANT = <<'EOT';
#@dogs = (
#  'Fido',
#  'Wags',
#  {
#    First => \'Fido',
#    Second => \'Wags'
#  }
#);
#%kennels = (
#  First => \'Fido',
#  Second => \'Wags'
#);
EOT

  TEST q(
	 $d = Data::Dumper->new( [\@dogs, \%kennel], [qw(*dogs *kennels)] );
	 $d->Deepcopy(1)->Dump;
	);
  if ($XS) {
    TEST q($d->Reset->Dumpxs);
  }
  
}

{

sub z { print "foo\n" }
$c = [ \&z ];

############# 121
##
  $WANT = <<'EOT';
#$a = $b;
#$c = [
#  $b
#];
EOT

TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
	if $XS;

############# 127
##
  $WANT = <<'EOT';
#$a = \&b;
#$c = [
#  \&b
#];
EOT

TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
	if $XS;

############# 133
##
  $WANT = <<'EOT';
#*a = \&b;
#@c = (
#  \&b
#);
EOT

TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dump;);
TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dumpxs;)
	if $XS;

}

{
  $a = [];
  $a->[1] = \$a->[0];

############# 139
##
  $WANT = <<'EOT';
#@a = (
#  undef,
#  do{my $o}
#);
#$a[1] = \$a[0];
EOT

TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dump;);
TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dumpxs;)
	if $XS;
}

{
  $a = \\\\\'foo';
  $b = $$$a;

############# 145
##
  $WANT = <<'EOT';
#$a = \\\\\'foo';
#$b = ${${$a}};
EOT

TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
	if $XS;
}

{
  $a = [{ a => \$b }, { b => undef }];
  $b = [{ c => \$b }, { d => \$a }];

############# 151
##
  $WANT = <<'EOT';
#$a = [
#  {
#    a => \[
#        {
#          c => do{my $o}
#        },
#        {
#          d => \[]
#        }
#      ]
#  },
#  {
#    b => undef
#  }
#];
#${$a->[0]{a}}->[0]->{c} = $a->[0]{a};
#${${$a->[0]{a}}->[1]->{d}} = $a;
#$b = ${$a->[0]{a}};
EOT

TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
	if $XS;
}

{
  $a = [[[[\\\\\'foo']]]];
  $b = $a->[0][0];
  $c = $${$b->[0][0]};

############# 157
##
  $WANT = <<'EOT';
#$a = [
#  [
#    [
#      [
#        \\\\\'foo'
#      ]
#    ]
#  ]
#];
#$b = $a->[0][0];
#$c = ${${$a->[0][0][0][0]}};
EOT

TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dump;);
TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dumpxs;)
	if $XS;
}

{
    $f = "pearl";
    $e = [        $f ];
    $d = { 'e' => $e };
    $c = [        $d ];
    $b = { 'c' => $c };
    $a = { 'b' => $b };

############# 163
##
  $WANT = <<'EOT';
#$a = {
#  b => {
#    c => [
#      {
#        e => 'ARRAY(0xdeadbeef)'
#      }
#    ]
#  }
#};
#$b = $a->{b};
#$c = $a->{b}{c};
EOT

TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(4)->Dump;);
TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(4)->Dumpxs;)
	if $XS;

############# 169
##
  $WANT = <<'EOT';
#$a = {
#  b => 'HASH(0xdeadbeef)'
#};
#$b = $a->{b};
#$c = [
#  'HASH(0xdeadbeef)'
#];
EOT

TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(1)->Dump;);
TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(1)->Dumpxs;)
	if $XS;
}

{
    $a = \$a;
    $b = [$a];

############# 175
##
  $WANT = <<'EOT';
#$b = [
#  \$b->[0]
#];
EOT

TEST q(Data::Dumper->new([$b],['b'])->Purity(0)->Dump;);
TEST q(Data::Dumper->new([$b],['b'])->Purity(0)->Dumpxs;)
	if $XS;

############# 181
##
  $WANT = <<'EOT';
#$b = [
#  \do{my $o}
#];
#${$b->[0]} = $b->[0];
EOT


TEST q(Data::Dumper->new([$b],['b'])->Purity(1)->Dump;);
TEST q(Data::Dumper->new([$b],['b'])->Purity(1)->Dumpxs;)
	if $XS;
}
Commit	Line	Data
823edd99 GS	1	#!./perl -w
	2	#
	3	# testsuite for Data::Dumper
	4	#
	5
	6	BEGIN {
	7	chdir 't' if -d 't';
20822f61	8	@INC = '../lib';
be3174d2 GS	9	require Config; import Config;
	10	if ($Config{'extensions'} !~ /\bData\/Dumper\b/) {
	11	print "1..0 # Skip: Data::Dumper was not built\n";
	12	exit 0;
	13	}
823edd99 GS	14	}
	15
	16	use Data::Dumper;
f70c35af GS	17	use Config;
f70c35af GS	18	my $Is_ebcdic = defined($Config{'ebcdic'}) && $Config{'ebcdic'} eq 'define';
823edd99 GS	19
	20	$Data::Dumper::Pad = "#";
	21	my $TMAX;
	22	my $XS;
	23	my $TNUM = 0;
	24	my $WANT = '';
	25
	26	sub TEST {
	27	my $string = shift;
	28	my $t = eval $string;
	29	++$TNUM;
a2126434 JN	30	$t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
a2126434 JN	31	if ($WANT =~ /deadbeef/);
f70c35af GS	32	if ($Is_ebcdic) {
	33	# these data need massaging with non ascii character sets
	34	# because of hashing order differences
	35	$WANT = join("\n",sort(split(/\n/,$WANT)));
	36	$WANT =~ s/\,$//mg;
	37	$t = join("\n",sort(split(/\n/,$t)));
	38	$t =~ s/\,$//mg;
	39	}
823edd99 GS	40	print( ($t eq $WANT and not $@) ? "ok $TNUM\n"
	41	: "not ok $TNUM\n--Expected--\n$WANT\n--Got--\n$@$t\n");
	42
	43	++$TNUM;
	44	eval "$t";
	45	print $@ ? "not ok $TNUM\n# \$@ says: $@\n" : "ok $TNUM\n";
	46
	47	$t = eval $string;
	48	++$TNUM;
a2126434 JN	49	$t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
a2126434 JN	50	if ($WANT =~ /deadbeef/);
f70c35af GS	51	if ($Is_ebcdic) {
	52	# here too there are hashing order differences
	53	$WANT = join("\n",sort(split(/\n/,$WANT)));
	54	$WANT =~ s/\,$//mg;
	55	$t = join("\n",sort(split(/\n/,$t)));
	56	$t =~ s/\,$//mg;
	57	}
823edd99 GS	58	print( ($t eq $WANT and not $@) ? "ok $TNUM\n"
	59	: "not ok $TNUM\n--Expected--\n$WANT\n--Got--\n$@$t\n");
	60	}
	61
	62	if (defined &Data::Dumper::Dumpxs) {
	63	print "### XS extension loaded, will run XS tests\n";
5df59fb6	64	$TMAX = 186; $XS = 1;
823edd99 GS	65	}
	66	else {
	67	print "### XS extensions not loaded, will NOT run XS tests\n";
5df59fb6	68	$TMAX = 93; $XS = 0;
823edd99 GS	69	}
	70
	71	print "1..$TMAX\n";
	72
	73	#############
	74	#############
	75
	76	@c = ('c');
	77	$c = \@c;
	78	$b = {};
	79	$a = [1, $b, $c];
	80	$b->{a} = $a;
	81	$b->{b} = $a->[1];
	82	$b->{c} = $a->[2];
	83
	84	############# 1
	85	##
	86	$WANT = <<'EOT';
	87	#$a = [
	88	# 1,
	89	# {
	90	# 'a' => $a,
	91	# 'b' => $a->[1],
	92	# 'c' => [
	93	# 'c'
	94	# ]
	95	# },
	96	# $a->[1]{'c'}
	97	# ];
	98	#$b = $a->[1];
	99	#$c = $a->[1]{'c'};
	100	EOT
	101
	102	TEST q(Data::Dumper->Dump([$a,$b,$c], [qw(a b c)]));
	103	TEST q(Data::Dumper->Dumpxs([$a,$b,$c], [qw(a b c)])) if $XS;
	104
	105
	106	############# 7
	107	##
	108	$WANT = <<'EOT';
	109	#@a = (
	110	# 1,
	111	# {
	112	# 'a' => [],
	113	# 'b' => {},
	114	# 'c' => [
	115	# 'c'
	116	# ]
	117	# },
	118	# []
	119	# );
	120	#$a[1]{'a'} = \@a;
	121	#$a[1]{'b'} = $a[1];
	122	#$a[2] = $a[1]{'c'};
	123	#$b = $a[1];
	124	EOT
	125
	126	$Data::Dumper::Purity = 1; # fill in the holes for eval
	127	TEST q(Data::Dumper->Dump([$a, $b], [qw(*a b)])); # print as @a
	128	TEST q(Data::Dumper->Dumpxs([$a, $b], [qw(*a b)])) if $XS;
	129
	130	############# 13
	131	##
	132	$WANT = <<'EOT';
133	#%b = (
134	# 'a' => [
135	# 1,
136	# {},
137	# [
138	# 'c'
139	# ]
140	# ],
141	# 'b' => {},
142	# 'c' => []
143	# );
144	#$b{'a'}[1] = \%b;
145	#$b{'b'} = \%b;
146	#$b{'c'} = $b{'a'}[2];
147	#$a = $b{'a'};
148	EOT
149
150	TEST q(Data::Dumper->Dump([$b, $a], [qw(*b a)])); # print as %b
151	TEST q(Data::Dumper->Dumpxs([$b, $a], [qw(*b a)])) if $XS;
152
153	############# 19
154	##
155	$WANT = <<'EOT';
156	#$a = [
157	# 1,
158	# {
159	# 'a' => [],
160	# 'b' => {},
161	# 'c' => []
162	# },
163	# []
164	#];
165	#$a->[1]{'a'} = $a;
166	#$a->[1]{'b'} = $a->[1];
167	#$a->[1]{'c'} = \@c;
168	#$a->[2] = \@c;
169	#$b = $a->[1];
170	EOT
171
172	$Data::Dumper::Indent = 1;
173	TEST q(
174	$d = Data::Dumper->new([$a,$b], [qw(a b)]);
175	$d->Seen({'*c' => $c});
176	$d->Dump;
177	);
178	if ($XS) {
179	TEST q(
180	$d = Data::Dumper->new([$a,$b], [qw(a b)]);
181	$d->Seen({'*c' => $c});
182	$d->Dumpxs;
183	);
184	}
185
186
187	############# 25
188	##
189	$WANT = <<'EOT';
190	#$a = [
191	# #0
192	# 1,
193	# #1
194	# {
195	# a => $a,
196	# b => $a->[1],
197	# c => [
198	# #0
199	# 'c'
200	# ]
201	# },
202	# #2
203	# $a->[1]{c}
204	# ];
205	#$b = $a->[1];
206	EOT
207
208	$d->Indent(3);
209	$d->Purity(0)->Quotekeys(0);
210	TEST q( $d->Reset; $d->Dump );
211
212	TEST q( $d->Reset; $d->Dumpxs ) if $XS;
213
214	############# 31
215	##
216	$WANT = <<'EOT';
217	#$VAR1 = [
218	# 1,
219	# {
220	# 'a' => [],
221	# 'b' => {},
222	# 'c' => [
223	# 'c'
224	# ]
225	# },
226	# []
227	#];
228	#$VAR1->[1]{'a'} = $VAR1;
229	#$VAR1->[1]{'b'} = $VAR1->[1];
230	#$VAR1->[2] = $VAR1->[1]{'c'};
231	EOT
232
233	TEST q(Dumper($a));
234	TEST q(Data::Dumper::DumperX($a)) if $XS;
235
236	############# 37
237	##
238	$WANT = <<'EOT';
239	#[
240	# 1,
241	# {
242	# a => $VAR1,
243	# b => $VAR1->[1],
244	# c => [
245	# 'c'
246	# ]
247	# },
248	# $VAR1->[1]{c}
249	#]
250	EOT
251
252	{
253	local $Data::Dumper::Purity = 0;
254	local $Data::Dumper::Quotekeys = 0;
255	local $Data::Dumper::Terse = 1;
256	TEST q(Dumper($a));
257	TEST q(Data::Dumper::DumperX($a)) if $XS;
258	}
259
260
261	############# 43
262	##
263	$WANT = <<'EOT';
264	#$VAR1 = {
0f4592ef	265	# "abc\0'\efg" => "mno\0"
823edd99 GS	266	#};
	267	EOT
	268
0f4592ef	269	$foo = { "abc\000\'\efg" => "mno\000" };
823edd99 GS	270	{
	271	local $Data::Dumper::Useqq = 1;
	272	TEST q(Dumper($foo));
	273	}
	274
	275	$WANT = <<"EOT";
	276	#\$VAR1 = {
0f4592ef	277	# 'abc\0\\'\efg' => 'mno\0'
823edd99 GS	278	#};
	279	EOT
	280
	281	{
	282	local $Data::Dumper::Useqq = 1;
	283	TEST q(Data::Dumper::DumperX($foo)) if $XS; # cheat
	284	}
	285
	286
	287
	288	#############
	289	#############
	290
	291	{
	292	package main;
	293	use Data::Dumper;
	294	$foo = 5;
f32b5c8a	295	@foo = (-10,\*foo);
823edd99 GS	296	%foo = (a=>1,b=>\$foo,c=>\@foo);
	297	$foo{d} = \%foo;
	298	$foo[2] = \%foo;
	299
	300	############# 49
	301	##
	302	$WANT = <<'EOT';
	303	#$foo = \*::foo;
	304	#*::foo = \5;
	305	#*::foo = [
	306	# #0
f32b5c8a	307	# -10,
823edd99	308	# #1
5df59fb6	309	# do{my $o},
823edd99 GS	310	# #2
	311	# {
	312	# 'a' => 1,
5df59fb6	313	# 'b' => do{my $o},
823edd99 GS	314	# 'c' => [],
	315	# 'd' => {}
	316	# }
	317	# ];
	318	#*::foo{ARRAY}->[1] = $foo;
	319	#::foo{ARRAY}->[2]{'b'} = ::foo{SCALAR};
	320	#::foo{ARRAY}->[2]{'c'} = ::foo{ARRAY};
	321	#::foo{ARRAY}->[2]{'d'} = ::foo{ARRAY}->[2];
	322	#::foo = ::foo{ARRAY}->[2];
	323	#@bar = @{*::foo{ARRAY}};
	324	#%baz = %{*::foo{ARRAY}->[2]};
	325	EOT
	326
	327	$Data::Dumper::Purity = 1;
	328	$Data::Dumper::Indent = 3;
	329	TEST q(Data::Dumper->Dump([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	330	TEST q(Data::Dumper->Dumpxs([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	331
	332	############# 55
	333	##
	334	$WANT = <<'EOT';
	335	#$foo = \*::foo;
	336	#*::foo = \5;
	337	#*::foo = [
f32b5c8a	338	# -10,
5df59fb6	339	# do{my $o},
823edd99 GS	340	# {
823edd99 GS	341	# 'a' => 1,
5df59fb6	342	# 'b' => do{my $o},
823edd99 GS	343	# 'c' => [],
	344	# 'd' => {}
	345	# }
	346	#];
	347	#*::foo{ARRAY}->[1] = $foo;
	348	#::foo{ARRAY}->[2]{'b'} = ::foo{SCALAR};
	349	#::foo{ARRAY}->[2]{'c'} = ::foo{ARRAY};
	350	#::foo{ARRAY}->[2]{'d'} = ::foo{ARRAY}->[2];
	351	#::foo = ::foo{ARRAY}->[2];
	352	#$bar = *::foo{ARRAY};
	353	#$baz = *::foo{ARRAY}->[2];
	354	EOT
	355
	356	$Data::Dumper::Indent = 1;
	357	TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	358	TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	359
	360	############# 61
	361	##
	362	$WANT = <<'EOT';
	363	#@bar = (
f32b5c8a	364	# -10,
823edd99 GS	365	# \*::foo,
	366	# {}
	367	#);
	368	#*::foo = \5;
	369	#*::foo = \@bar;
	370	#*::foo = {
	371	# 'a' => 1,
5df59fb6	372	# 'b' => do{my $o},
823edd99 GS	373	# 'c' => [],
	374	# 'd' => {}
	375	#};
	376	#::foo{HASH}->{'b'} = ::foo{SCALAR};
	377	#*::foo{HASH}->{'c'} = \@bar;
	378	#::foo{HASH}->{'d'} = ::foo{HASH};
	379	#$bar[2] = *::foo{HASH};
	380	#%baz = %{*::foo{HASH}};
	381	#$foo = $bar[1];
	382	EOT
	383
	384	TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\foo], ['bar', 'baz', 'foo']));
	385	TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\foo], ['bar', 'baz', 'foo'])) if $XS;
	386
	387	############# 67
	388	##
	389	$WANT = <<'EOT';
	390	#$bar = [
f32b5c8a	391	# -10,
823edd99 GS	392	# \*::foo,
	393	# {}
	394	#];
	395	#*::foo = \5;
	396	#*::foo = $bar;
	397	#*::foo = {
	398	# 'a' => 1,
5df59fb6	399	# 'b' => do{my $o},
823edd99 GS	400	# 'c' => [],
	401	# 'd' => {}
	402	#};
	403	#::foo{HASH}->{'b'} = ::foo{SCALAR};
	404	#*::foo{HASH}->{'c'} = $bar;
	405	#::foo{HASH}->{'d'} = ::foo{HASH};
	406	#$bar->[2] = *::foo{HASH};
	407	#$baz = *::foo{HASH};
	408	#$foo = $bar->[1];
	409	EOT
	410
	411	TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo']));
	412	TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo'])) if $XS;
	413
	414	############# 73
	415	##
	416	$WANT = <<'EOT';
	417	#$foo = \*::foo;
	418	#@bar = (
f32b5c8a	419	# -10,
823edd99 GS	420	# $foo,
	421	# {
	422	# a => 1,
	423	# b => \5,
	424	# c => \@bar,
	425	# d => $bar[2]
	426	# }
	427	#);
	428	#%baz = %{$bar[2]};
	429	EOT
	430
	431	$Data::Dumper::Purity = 0;
	432	$Data::Dumper::Quotekeys = 0;
	433	TEST q(Data::Dumper->Dump([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	434	TEST q(Data::Dumper->Dumpxs([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	435
	436	############# 79
	437	##
	438	$WANT = <<'EOT';
	439	#$foo = \*::foo;
	440	#$bar = [
f32b5c8a	441	# -10,
823edd99 GS	442	# $foo,
	443	# {
	444	# a => 1,
	445	# b => \5,
	446	# c => $bar,
	447	# d => $bar->[2]
	448	# }
	449	#];
	450	#$baz = $bar->[2];
	451	EOT
	452
	453	TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	454	TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	455
	456	}
	457
	458	#############
	459	#############
	460	{
	461	package main;
	462	@dogs = ( 'Fido', 'Wags' );
	463	%kennel = (
	464	First => \$dogs[0],
	465	Second => \$dogs[1],
	466	);
	467	$dogs[2] = \%kennel;
	468	$mutts = \%kennel;
	469	$mutts = $mutts; # avoid warning
	470
	471	############# 85
	472	##
	473	$WANT = <<'EOT';
	474	#%kennels = (
	475	# First => \'Fido',
	476	# Second => \'Wags'
	477	#);
	478	#@dogs = (
0f4592ef GS	479	# ${$kennels{First}},
0f4592ef GS	480	# ${$kennels{Second}},
823edd99 GS	481	# \%kennels
	482	#);
	483	#%mutts = %kennels;
	484	EOT
	485
	486	TEST q(
	487	$d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
	488	[qw(kennels dogs *mutts)] );
	489	$d->Dump;
	490	);
	491	if ($XS) {
	492	TEST q(
	493	$d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
	494	[qw(kennels dogs *mutts)] );
	495	$d->Dumpxs;
	496	);
	497	}
	498
	499	############# 91
	500	##
	501	$WANT = <<'EOT';
	502	#%kennels = %kennels;
	503	#@dogs = @dogs;
	504	#%mutts = %kennels;
	505	EOT
	506
	507	TEST q($d->Dump);
	508	TEST q($d->Dumpxs) if $XS;
	509
	510	############# 97
	511	##
	512	$WANT = <<'EOT';
	513	#%kennels = (
	514	# First => \'Fido',
	515	# Second => \'Wags'
	516	#);
	517	#@dogs = (
0f4592ef GS	518	# ${$kennels{First}},
0f4592ef GS	519	# ${$kennels{Second}},
823edd99 GS	520	# \%kennels
	521	#);
	522	#%mutts = %kennels;
	523	EOT
	524
	525
	526	TEST q($d->Reset; $d->Dump);
	527	if ($XS) {
	528	TEST q($d->Reset; $d->Dumpxs);
	529	}
	530
	531	############# 103
	532	##
	533	$WANT = <<'EOT';
	534	#@dogs = (
	535	# 'Fido',
	536	# 'Wags',
	537	# {
	538	# First => \$dogs[0],
	539	# Second => \$dogs[1]
	540	# }
	541	#);
	542	#%kennels = %{$dogs[2]};
	543	#%mutts = %{$dogs[2]};
	544	EOT
	545
	546	TEST q(
	547	$d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
	548	[qw(dogs kennels *mutts)] );
	549	$d->Dump;
	550	);
	551	if ($XS) {
	552	TEST q(
	553	$d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
	554	[qw(dogs kennels *mutts)] );
	555	$d->Dumpxs;
	556	);
	557	}
	558
	559	############# 109
	560	##
	561	TEST q($d->Reset->Dump);
	562	if ($XS) {
	563	TEST q($d->Reset->Dumpxs);
	564	}
	565
	566	############# 115
	567	##
	568	$WANT = <<'EOT';
	569	#@dogs = (
	570	# 'Fido',
	571	# 'Wags',
	572	# {
	573	# First => \'Fido',
	574	# Second => \'Wags'
	575	# }
	576	#);
	577	#%kennels = (
	578	# First => \'Fido',
	579	# Second => \'Wags'
	580	#);
	581	EOT
	582
	583	TEST q(
584	$d = Data::Dumper->new( [\@dogs, \%kennel], [qw(dogs kennels)] );
585	$d->Deepcopy(1)->Dump;
586	);
587	if ($XS) {
588	TEST q($d->Reset->Dumpxs);
589	}
590
591	}
592
593	{
594
0f4592ef GS	595	sub z { print "foo\n" }
0f4592ef GS	596	$c = [ \&z ];
823edd99 GS	597
	598	############# 121
	599	##
	600	$WANT = <<'EOT';
	601	#$a = $b;
	602	#$c = [
	603	# $b
	604	#];
	605	EOT
	606
0f4592ef GS	607	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
0f4592ef GS	608	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
823edd99 GS	609	if $XS;
	610
	611	############# 127
	612	##
	613	$WANT = <<'EOT';
	614	#$a = \&b;
	615	#$c = [
	616	# \&b
	617	#];
	618	EOT
	619
0f4592ef GS	620	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
0f4592ef GS	621	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
823edd99 GS	622	if $XS;
	623
	624	############# 133
	625	##
	626	$WANT = <<'EOT';
	627	#*a = \&b;
	628	#@c = (
	629	# \&b
	630	#);
	631	EOT
	632
0f4592ef GS	633	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
0f4592ef GS	634	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
823edd99 GS	635	if $XS;
	636
	637	}
0f4592ef GS	638
	639	{
	640	$a = [];
	641	$a->[1] = \$a->[0];
	642
	643	############# 139
	644	##
	645	$WANT = <<'EOT';
	646	#@a = (
	647	# undef,
5df59fb6	648	# do{my $o}
0f4592ef GS	649	#);
	650	#$a[1] = \$a[0];
	651	EOT
	652
	653	TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dump;);
	654	TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dumpxs;)
	655	if $XS;
	656	}
	657
	658	{
	659	$a = \\\\\'foo';
	660	$b = $$$a;
	661
	662	############# 145
	663	##
	664	$WANT = <<'EOT';
	665	#$a = \\\\\'foo';
	666	#$b = ${${$a}};
	667	EOT
	668
	669	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
	670	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
	671	if $XS;
	672	}
	673
	674	{
	675	$a = [{ a => \$b }, { b => undef }];
	676	$b = [{ c => \$b }, { d => \$a }];
	677
	678	############# 151
	679	##
	680	$WANT = <<'EOT';
	681	#$a = [
	682	# {
	683	# a => \[
	684	# {
5df59fb6	685	# c => do{my $o}
0f4592ef GS	686	# },
	687	# {
	688	# d => \[]
	689	# }
	690	# ]
	691	# },
	692	# {
	693	# b => undef
	694	# }
	695	#];
	696	#${$a->[0]{a}}->[0]->{c} = $a->[0]{a};
	697	#${${$a->[0]{a}}->[1]->{d}} = $a;
	698	#$b = ${$a->[0]{a}};
	699	EOT
	700
	701	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
	702	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
	703	if $XS;
	704	}
	705
	706	{
	707	$a = [[[[\\\\\'foo']]]];
	708	$b = $a->[0][0];
	709	$c = $${$b->[0][0]};
	710
	711	############# 157
	712	##
	713	$WANT = <<'EOT';
	714	#$a = [
	715	# [
	716	# [
	717	# [
	718	# \\\\\'foo'
	719	# ]
	720	# ]
	721	# ]
	722	#];
	723	#$b = $a->[0][0];
	724	#$c = ${${$a->[0][0][0][0]}};
	725	EOT
	726
	727	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dump;);
	728	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dumpxs;)
	729	if $XS;
	730	}
a2126434 JN	731
	732	{
	733	$f = "pearl";
	734	$e = [ $f ];
	735	$d = { 'e' => $e };
	736	$c = [ $d ];
	737	$b = { 'c' => $c };
	738	$a = { 'b' => $b };
	739
	740	############# 163
	741	##
	742	$WANT = <<'EOT';
	743	#$a = {
	744	# b => {
	745	# c => [
	746	# {
	747	# e => 'ARRAY(0xdeadbeef)'
	748	# }
	749	# ]
	750	# }
	751	#};
	752	#$b = $a->{b};
	753	#$c = $a->{b}{c};
	754	EOT
	755
	756	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(4)->Dump;);
	757	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(4)->Dumpxs;)
	758	if $XS;
	759
	760	############# 169
	761	##
	762	$WANT = <<'EOT';
	763	#$a = {
	764	# b => 'HASH(0xdeadbeef)'
	765	#};
	766	#$b = $a->{b};
	767	#$c = [
	768	# 'HASH(0xdeadbeef)'
	769	#];
	770	EOT
	771
	772	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(1)->Dump;);
	773	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(1)->Dumpxs;)
	774	if $XS;
	775	}
5df59fb6 GS	776
	777	{
	778	$a = \$a;
	779	$b = [$a];
	780
	781	############# 175
	782	##
	783	$WANT = <<'EOT';
	784	#$b = [
	785	# \$b->[0]
	786	#];
	787	EOT
	788
	789	TEST q(Data::Dumper->new([$b],['b'])->Purity(0)->Dump;);
	790	TEST q(Data::Dumper->new([$b],['b'])->Purity(0)->Dumpxs;)
	791	if $XS;
	792
	793	############# 181
	794	##
	795	$WANT = <<'EOT';
	796	#$b = [
	797	# \do{my $o}
	798	#];
	799	#${$b->[0]} = $b->[0];
	800	EOT
	801
	802
	803	TEST q(Data::Dumper->new([$b],['b'])->Purity(1)->Dump;);
	804	TEST q(Data::Dumper->new([$b],['b'])->Purity(1)->Dumpxs;)
	805	if $XS;
	806	}