[p5sagit/p5-mst-13.2.git] / t / lib / dumper.t

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

BEGIN {
    chdir 't' if -d 't';
    unshift @INC, '../lib' if -d '../lib';
}

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/);
  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/);
  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 = 174; $XS = 1;
}
else {
  print "### XS extensions not loaded, will NOT run XS tests\n";
  $TMAX = 87; $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
##
if (!$Is_ebcdic) {
$WANT = <<'EOT';
#$VAR1 = {
#  "abc\0'\efg" => "mno\0"
#};
EOT
}
else {
$WANT = <<"EOT";
#\$VAR1 = {
#  "\\201\\202\\203\\340\\360'\e\\206\\207" => "\\224\\225\\226\\340\\360"
#};
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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#$foo = \*::foo;
#*::foo = \5;
#*::foo = [
#           #0
#           10,
#           #1
#           '',
#           #2
#           {
#             'a' => 1,
#             'b' => '',
#             '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
}
else {
  $WANT = <<'EOT';
#$foo = \*::foo;
#*::foo = \5;
#*::foo = [
#           #0
#           10,
#           #1
#           '',
#           #2
#           {
#             'd' => {},
#             'a' => 1,
#             'b' => '',
#             'c' => []
#           }
#         ];
#*::foo{ARRAY}->[1] = $foo;
#*::foo{ARRAY}->[2]{'d'} = *::foo{ARRAY}->[2];
#*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
#*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
#*::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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#$foo = \*::foo;
#*::foo = \5;
#*::foo = [
#  10,
#  '',
#  {
#    'a' => 1,
#    'b' => '',
#    '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
}
else {
  $WANT = <<'EOT';
#$foo = \*::foo;
#*::foo = \5;
#*::foo = [
#  10,
#  '',
#  {
#    'd' => {},
#    'a' => 1,
#    'b' => '',
#    'c' => []
#  }
#];
#*::foo{ARRAY}->[1] = $foo;
#*::foo{ARRAY}->[2]{'d'} = *::foo{ARRAY}->[2];
#*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
#*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
#*::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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#@bar = (
#  10,
#  \*::foo,
#  {}
#);
#*::foo = \5;
#*::foo = \@bar;
#*::foo = {
#  'a' => 1,
#  'b' => '',
#  '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
}
else {
  $WANT = <<'EOT';
#@bar = (
#  10,
#  \*::foo,
#  {}
#);
#*::foo = \5;
#*::foo = \@bar;
#*::foo = {
#  'd' => {},
#  'a' => 1,
#  'b' => '',
#  'c' => []
#};
#*::foo{HASH}->{'d'} = *::foo{HASH};
#*::foo{HASH}->{'b'} = *::foo{SCALAR};
#*::foo{HASH}->{'c'} = \@bar;
#$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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#$bar = [
#  10,
#  \*::foo,
#  {}
#];
#*::foo = \5;
#*::foo = $bar;
#*::foo = {
#  'a' => 1,
#  'b' => '',
#  '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
}
else {
  $WANT = <<'EOT';
#$bar = [
#  10,
#  \*::foo,
#  {}
#];
#*::foo = \5;
#*::foo = $bar;
#*::foo = {
#  'd' => {},
#  'a' => 1,
#  'b' => '',
#  'c' => []
#};
#*::foo{HASH}->{'d'} = *::foo{HASH};
#*::foo{HASH}->{'b'} = *::foo{SCALAR};
#*::foo{HASH}->{'c'} = $bar;
#$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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#$foo = \*::foo;
#@bar = (
#  10,
#  $foo,
#  {
#    a => 1,
#    b => \5,
#    c => \@bar,
#    d => $bar[2]
#  }
#);
#%baz = %{$bar[2]};
EOT
}
else {
  $WANT = <<'EOT';
#$foo = \*::foo;
#@bar = (
#  10,
#  $foo,
#  {
#    d => $bar[2],
#    a => 1,
#    b => \5,
#    c => \@bar
#  }
#);
#%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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#$foo = \*::foo;
#$bar = [
#  10,
#  $foo,
#  {
#    a => 1,
#    b => \5,
#    c => $bar,
#    d => $bar->[2]
#  }
#];
#$baz = $bar->[2];
EOT
}
else {
  $WANT = <<'EOT';
#$foo = \*::foo;
#$bar = [
#  10,
#  $foo,
#  {
#    d => $bar->[2],
#    a => 1,
#    b => \5,
#    c => $bar
#  }
#];
#$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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#%kennels = (
#  First => \'Fido',
#  Second => \'Wags'
#);
#@dogs = (
#  ${$kennels{First}},
#  ${$kennels{Second}},
#  \%kennels
#);
#%mutts = %kennels;
EOT
}
else {
  $WANT = <<'EOT';
#%kennels = (
#  Second => \'Wags',
#  First => \'Fido'
#);
#@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
##
if (!$Is_ebcdic) {
  $WANT = <<'EOT';
#%kennels = (
#  First => \'Fido',
#  Second => \'Wags'
#);
#@dogs = (
#  ${$kennels{First}},
#  ${$kennels{Second}},
#  \%kennels
#);
#%mutts = %kennels;
EOT
}
else {
  $WANT = <<'EOT';
#%kennels = (
#  Second => \'Wags',
#  First => \'Fido'
#);
#@dogs = (
#  ${$kennels{First}},
#  ${$kennels{Second}},
#  \%kennels
#);
#%mutts = %kennels;
EOT
}

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

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