[p5sagit/p5-mst-13.2.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",
#  "reftest" => \\1
#};
EOT

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

  $WANT = <<"EOT";
#\$VAR1 = {
#  'abc\0\\'\efg' => 'mno\0',
#  'reftest' => \\\\1
#};
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	1	#!./perl -w
	2	#
	3	# testsuite for Data::Dumper
	4	#
	5
	6	BEGIN {
	7	chdir 't' if -d 't';
22d4bb9c	8	@INC = '../lib';
4b19af01	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	14	}
	15
	16	use Data::Dumper;
146174a9	17	use Config;
146174a9	18	my $Is_ebcdic = defined($Config{'ebcdic'}) && $Config{'ebcdic'} eq 'define';
823edd99	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;
c529f79d	30	$t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
c529f79d	31	if ($WANT =~ /deadbeef/);
146174a9	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	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;
c529f79d	49	$t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
c529f79d	50	if ($WANT =~ /deadbeef/);
146174a9	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	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";
cb50131a	64	$TMAX = 186; $XS = 1;
823edd99	65	}
	66	else {
	67	print "### XS extensions not loaded, will NOT run XS tests\n";
cb50131a	68	$TMAX = 93; $XS = 0;
823edd99	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 = {
22d4bb9c	265	# "abc\0'\efg" => "mno\0",
22d4bb9c	266	# "reftest" => \\1
823edd99	267	#};
	268	EOT
	269
22d4bb9c	270	$foo = { "abc\000\'\efg" => "mno\000",
	271	"reftest" => \\1,
	272	};
823edd99	273	{
	274	local $Data::Dumper::Useqq = 1;
	275	TEST q(Dumper($foo));
	276	}
	277
	278	$WANT = <<"EOT";
	279	#\$VAR1 = {
22d4bb9c	280	# 'abc\0\\'\efg' => 'mno\0',
22d4bb9c	281	# 'reftest' => \\\\1
823edd99	282	#};
	283	EOT
	284
	285	{
	286	local $Data::Dumper::Useqq = 1;
	287	TEST q(Data::Dumper::DumperX($foo)) if $XS; # cheat
	288	}
	289
	290
	291
	292	#############
	293	#############
	294
	295	{
	296	package main;
	297	use Data::Dumper;
	298	$foo = 5;
ee8c7f54	299	@foo = (-10,\*foo);
823edd99	300	%foo = (a=>1,b=>\$foo,c=>\@foo);
	301	$foo{d} = \%foo;
	302	$foo[2] = \%foo;
	303
	304	############# 49
	305	##
	306	$WANT = <<'EOT';
	307	#$foo = \*::foo;
	308	#*::foo = \5;
	309	#*::foo = [
	310	# #0
ee8c7f54	311	# -10,
823edd99	312	# #1
cb50131a	313	# do{my $o},
823edd99	314	# #2
	315	# {
	316	# 'a' => 1,
cb50131a	317	# 'b' => do{my $o},
823edd99	318	# 'c' => [],
	319	# 'd' => {}
	320	# }
	321	# ];
	322	#*::foo{ARRAY}->[1] = $foo;
	323	#::foo{ARRAY}->[2]{'b'} = ::foo{SCALAR};
	324	#::foo{ARRAY}->[2]{'c'} = ::foo{ARRAY};
	325	#::foo{ARRAY}->[2]{'d'} = ::foo{ARRAY}->[2];
	326	#::foo = ::foo{ARRAY}->[2];
	327	#@bar = @{*::foo{ARRAY}};
	328	#%baz = %{*::foo{ARRAY}->[2]};
	329	EOT
	330
	331	$Data::Dumper::Purity = 1;
	332	$Data::Dumper::Indent = 3;
	333	TEST q(Data::Dumper->Dump([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	334	TEST q(Data::Dumper->Dumpxs([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	335
	336	############# 55
	337	##
	338	$WANT = <<'EOT';
	339	#$foo = \*::foo;
	340	#*::foo = \5;
	341	#*::foo = [
ee8c7f54	342	# -10,
cb50131a	343	# do{my $o},
823edd99	344	# {
823edd99	345	# 'a' => 1,
cb50131a	346	# 'b' => do{my $o},
823edd99	347	# 'c' => [],
	348	# 'd' => {}
	349	# }
	350	#];
	351	#*::foo{ARRAY}->[1] = $foo;
	352	#::foo{ARRAY}->[2]{'b'} = ::foo{SCALAR};
	353	#::foo{ARRAY}->[2]{'c'} = ::foo{ARRAY};
	354	#::foo{ARRAY}->[2]{'d'} = ::foo{ARRAY}->[2];
	355	#::foo = ::foo{ARRAY}->[2];
	356	#$bar = *::foo{ARRAY};
	357	#$baz = *::foo{ARRAY}->[2];
	358	EOT
	359
	360	$Data::Dumper::Indent = 1;
	361	TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	362	TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	363
	364	############# 61
	365	##
	366	$WANT = <<'EOT';
	367	#@bar = (
ee8c7f54	368	# -10,
823edd99	369	# \*::foo,
	370	# {}
	371	#);
	372	#*::foo = \5;
	373	#*::foo = \@bar;
	374	#*::foo = {
	375	# 'a' => 1,
cb50131a	376	# 'b' => do{my $o},
823edd99	377	# 'c' => [],
	378	# 'd' => {}
	379	#};
	380	#::foo{HASH}->{'b'} = ::foo{SCALAR};
	381	#*::foo{HASH}->{'c'} = \@bar;
	382	#::foo{HASH}->{'d'} = ::foo{HASH};
	383	#$bar[2] = *::foo{HASH};
	384	#%baz = %{*::foo{HASH}};
	385	#$foo = $bar[1];
	386	EOT
	387
	388	TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\foo], ['bar', 'baz', 'foo']));
	389	TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\foo], ['bar', 'baz', 'foo'])) if $XS;
	390
	391	############# 67
	392	##
	393	$WANT = <<'EOT';
	394	#$bar = [
ee8c7f54	395	# -10,
823edd99	396	# \*::foo,
	397	# {}
	398	#];
	399	#*::foo = \5;
	400	#*::foo = $bar;
	401	#*::foo = {
	402	# 'a' => 1,
cb50131a	403	# 'b' => do{my $o},
823edd99	404	# 'c' => [],
	405	# 'd' => {}
	406	#};
	407	#::foo{HASH}->{'b'} = ::foo{SCALAR};
	408	#*::foo{HASH}->{'c'} = $bar;
	409	#::foo{HASH}->{'d'} = ::foo{HASH};
	410	#$bar->[2] = *::foo{HASH};
	411	#$baz = *::foo{HASH};
	412	#$foo = $bar->[1];
	413	EOT
	414
	415	TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo']));
	416	TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo'])) if $XS;
	417
	418	############# 73
	419	##
	420	$WANT = <<'EOT';
	421	#$foo = \*::foo;
	422	#@bar = (
ee8c7f54	423	# -10,
823edd99	424	# $foo,
	425	# {
	426	# a => 1,
	427	# b => \5,
	428	# c => \@bar,
	429	# d => $bar[2]
	430	# }
	431	#);
	432	#%baz = %{$bar[2]};
	433	EOT
	434
	435	$Data::Dumper::Purity = 0;
	436	$Data::Dumper::Quotekeys = 0;
	437	TEST q(Data::Dumper->Dump([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	438	TEST q(Data::Dumper->Dumpxs([\\foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	439
	440	############# 79
	441	##
	442	$WANT = <<'EOT';
	443	#$foo = \*::foo;
	444	#$bar = [
ee8c7f54	445	# -10,
823edd99	446	# $foo,
	447	# {
	448	# a => 1,
	449	# b => \5,
	450	# c => $bar,
	451	# d => $bar->[2]
	452	# }
	453	#];
	454	#$baz = $bar->[2];
	455	EOT
	456
	457	TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
	458	TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
	459
	460	}
	461
	462	#############
	463	#############
	464	{
	465	package main;
	466	@dogs = ( 'Fido', 'Wags' );
	467	%kennel = (
	468	First => \$dogs[0],
	469	Second => \$dogs[1],
	470	);
	471	$dogs[2] = \%kennel;
	472	$mutts = \%kennel;
	473	$mutts = $mutts; # avoid warning
	474
	475	############# 85
	476	##
	477	$WANT = <<'EOT';
	478	#%kennels = (
	479	# First => \'Fido',
	480	# Second => \'Wags'
	481	#);
	482	#@dogs = (
0f4592ef	483	# ${$kennels{First}},
0f4592ef	484	# ${$kennels{Second}},
823edd99	485	# \%kennels
	486	#);
	487	#%mutts = %kennels;
	488	EOT
	489
	490	TEST q(
	491	$d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
	492	[qw(kennels dogs *mutts)] );
	493	$d->Dump;
	494	);
	495	if ($XS) {
	496	TEST q(
	497	$d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
	498	[qw(kennels dogs *mutts)] );
	499	$d->Dumpxs;
	500	);
	501	}
	502
	503	############# 91
	504	##
	505	$WANT = <<'EOT';
	506	#%kennels = %kennels;
	507	#@dogs = @dogs;
	508	#%mutts = %kennels;
	509	EOT
	510
	511	TEST q($d->Dump);
	512	TEST q($d->Dumpxs) if $XS;
	513
	514	############# 97
	515	##
	516	$WANT = <<'EOT';
	517	#%kennels = (
	518	# First => \'Fido',
	519	# Second => \'Wags'
	520	#);
	521	#@dogs = (
0f4592ef	522	# ${$kennels{First}},
0f4592ef	523	# ${$kennels{Second}},
823edd99	524	# \%kennels
	525	#);
	526	#%mutts = %kennels;
	527	EOT
	528
	529
	530	TEST q($d->Reset; $d->Dump);
	531	if ($XS) {
	532	TEST q($d->Reset; $d->Dumpxs);
	533	}
	534
	535	############# 103
	536	##
	537	$WANT = <<'EOT';
	538	#@dogs = (
	539	# 'Fido',
	540	# 'Wags',
	541	# {
	542	# First => \$dogs[0],
	543	# Second => \$dogs[1]
	544	# }
	545	#);
	546	#%kennels = %{$dogs[2]};
	547	#%mutts = %{$dogs[2]};
	548	EOT
	549
	550	TEST q(
	551	$d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
	552	[qw(dogs kennels *mutts)] );
	553	$d->Dump;
	554	);
	555	if ($XS) {
	556	TEST q(
	557	$d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
	558	[qw(dogs kennels *mutts)] );
	559	$d->Dumpxs;
	560	);
	561	}
	562
	563	############# 109
	564	##
	565	TEST q($d->Reset->Dump);
	566	if ($XS) {
	567	TEST q($d->Reset->Dumpxs);
	568	}
	569
	570	############# 115
	571	##
	572	$WANT = <<'EOT';
	573	#@dogs = (
	574	# 'Fido',
	575	# 'Wags',
	576	# {
	577	# First => \'Fido',
	578	# Second => \'Wags'
	579	# }
	580	#);
	581	#%kennels = (
	582	# First => \'Fido',
	583	# Second => \'Wags'
	584	#);
	585	EOT
	586
	587	TEST q(
588	$d = Data::Dumper->new( [\@dogs, \%kennel], [qw(dogs kennels)] );
589	$d->Deepcopy(1)->Dump;
590	);
591	if ($XS) {
592	TEST q($d->Reset->Dumpxs);
593	}
594
595	}
596
597	{
598
0f4592ef	599	sub z { print "foo\n" }
0f4592ef	600	$c = [ \&z ];
823edd99	601
	602	############# 121
	603	##
	604	$WANT = <<'EOT';
	605	#$a = $b;
	606	#$c = [
	607	# $b
	608	#];
	609	EOT
	610
0f4592ef	611	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
0f4592ef	612	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
823edd99	613	if $XS;
	614
	615	############# 127
	616	##
	617	$WANT = <<'EOT';
	618	#$a = \&b;
	619	#$c = [
	620	# \&b
	621	#];
	622	EOT
	623
0f4592ef	624	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
0f4592ef	625	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
823edd99	626	if $XS;
	627
	628	############# 133
	629	##
	630	$WANT = <<'EOT';
	631	#*a = \&b;
	632	#@c = (
	633	# \&b
	634	#);
	635	EOT
	636
0f4592ef	637	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
0f4592ef	638	TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
823edd99	639	if $XS;
	640
	641	}
0f4592ef	642
	643	{
	644	$a = [];
	645	$a->[1] = \$a->[0];
	646
	647	############# 139
	648	##
	649	$WANT = <<'EOT';
	650	#@a = (
	651	# undef,
cb50131a	652	# do{my $o}
0f4592ef	653	#);
	654	#$a[1] = \$a[0];
	655	EOT
	656
	657	TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dump;);
	658	TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dumpxs;)
	659	if $XS;
	660	}
	661
	662	{
	663	$a = \\\\\'foo';
	664	$b = $$$a;
	665
	666	############# 145
	667	##
	668	$WANT = <<'EOT';
	669	#$a = \\\\\'foo';
	670	#$b = ${${$a}};
	671	EOT
	672
	673	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
	674	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
	675	if $XS;
	676	}
	677
	678	{
	679	$a = [{ a => \$b }, { b => undef }];
	680	$b = [{ c => \$b }, { d => \$a }];
	681
	682	############# 151
	683	##
	684	$WANT = <<'EOT';
	685	#$a = [
	686	# {
	687	# a => \[
	688	# {
cb50131a	689	# c => do{my $o}
0f4592ef	690	# },
	691	# {
	692	# d => \[]
	693	# }
	694	# ]
	695	# },
	696	# {
	697	# b => undef
	698	# }
	699	#];
	700	#${$a->[0]{a}}->[0]->{c} = $a->[0]{a};
	701	#${${$a->[0]{a}}->[1]->{d}} = $a;
	702	#$b = ${$a->[0]{a}};
	703	EOT
	704
	705	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
	706	TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
	707	if $XS;
	708	}
	709
	710	{
	711	$a = [[[[\\\\\'foo']]]];
	712	$b = $a->[0][0];
	713	$c = $${$b->[0][0]};
	714
	715	############# 157
	716	##
	717	$WANT = <<'EOT';
	718	#$a = [
	719	# [
	720	# [
	721	# [
	722	# \\\\\'foo'
	723	# ]
	724	# ]
	725	# ]
	726	#];
	727	#$b = $a->[0][0];
	728	#$c = ${${$a->[0][0][0][0]}};
	729	EOT
	730
	731	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dump;);
	732	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dumpxs;)
	733	if $XS;
	734	}
c529f79d	735
	736	{
	737	$f = "pearl";
	738	$e = [ $f ];
	739	$d = { 'e' => $e };
	740	$c = [ $d ];
	741	$b = { 'c' => $c };
	742	$a = { 'b' => $b };
	743
	744	############# 163
	745	##
	746	$WANT = <<'EOT';
	747	#$a = {
	748	# b => {
	749	# c => [
	750	# {
	751	# e => 'ARRAY(0xdeadbeef)'
	752	# }
	753	# ]
	754	# }
	755	#};
	756	#$b = $a->{b};
	757	#$c = $a->{b}{c};
	758	EOT
	759
	760	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(4)->Dump;);
	761	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(4)->Dumpxs;)
	762	if $XS;
	763
	764	############# 169
	765	##
	766	$WANT = <<'EOT';
	767	#$a = {
	768	# b => 'HASH(0xdeadbeef)'
	769	#};
	770	#$b = $a->{b};
	771	#$c = [
	772	# 'HASH(0xdeadbeef)'
	773	#];
	774	EOT
	775
	776	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(1)->Dump;);
	777	TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Maxdepth(1)->Dumpxs;)
	778	if $XS;
	779	}
cb50131a	780
	781	{
	782	$a = \$a;
	783	$b = [$a];
	784
	785	############# 175
	786	##
	787	$WANT = <<'EOT';
	788	#$b = [
	789	# \$b->[0]
	790	#];
	791	EOT
	792
	793	TEST q(Data::Dumper->new([$b],['b'])->Purity(0)->Dump;);
	794	TEST q(Data::Dumper->new([$b],['b'])->Purity(0)->Dumpxs;)
	795	if $XS;
	796
	797	############# 181
	798	##
	799	$WANT = <<'EOT';
	800	#$b = [
	801	# \do{my $o}
	802	#];
	803	#${$b->[0]} = $b->[0];
	804	EOT
	805
	806
	807	TEST q(Data::Dumper->new([$b],['b'])->Purity(1)->Dump;);
	808	TEST q(Data::Dumper->new([$b],['b'])->Purity(1)->Dumpxs;)
	809	if $XS;
	810	}