t/lib/dumper.t

   1 #!./perl -w
   2 #
   3 # testsuite for Data::Dumper
   4 #
   5
   6 BEGIN {
   7     chdir 't' if -d 't';
   8     unshift @INC, '../lib' if -d '../lib';
   9 }
  10
  11 use Data::Dumper;
  12 use Config;
  13 my $Is_ebcdic = defined($Config{'ebcdic'}) && $Config{'ebcdic'} eq 'define';
  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;
  25   $t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
  26       if ($WANT =~ /deadbeef/);
  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;
  36   $t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
  37       if ($WANT =~ /deadbeef/);
  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";
  44   $TMAX = 174; $XS = 1;
  45 }
  46 else {
  47   print "### XS extensions not loaded, will NOT run XS tests\n";
  48   $TMAX = 87; $XS = 0;
  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 ##
 243 if (!$Is_ebcdic) {
 244 $WANT = <<'EOT';
 245 #$VAR1 = {
 246 #  "abc\0'\efg" => "mno\0"
 247 #};
 248 EOT
 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 }
 257
 258 $foo = { "abc\000\'\efg" => "mno\000" };
 259 {
 260   local $Data::Dumper::Useqq = 1;
 261   TEST q(Dumper($foo));
 262 }
 263
 264   $WANT = <<"EOT";
 265 #\$VAR1 = {
 266 #  'abc\0\\'\efg' => 'mno\0'
 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 ##
 291 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 351 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 404 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 456 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 508 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 548 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 601 if (!$Is_ebcdic) {
 602   $WANT = <<'EOT';
 603 #%kennels = (
 604 #  First => \'Fido',
 605 #  Second => \'Wags'
 606 #);
 607 #@dogs = (
 608 #  ${$kennels{First}},
 609 #  ${$kennels{Second}},
 610 #  \%kennels
 611 #);
 612 #%mutts = %kennels;
 613 EOT
 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 }
 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 ##
 656 if (!$Is_ebcdic) {
 657   $WANT = <<'EOT';
 658 #%kennels = (
 659 #  First => \'Fido',
 660 #  Second => \'Wags'
 661 #);
 662 #@dogs = (
 663 #  ${$kennels{First}},
 664 #  ${$kennels{Second}},
 665 #  \%kennels
 666 #);
 667 #%mutts = %kennels;
 668 EOT
 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 }
 684
 685
 686   TEST q($d->Reset; $d->Dump);
 687   if ($XS) {
 688     TEST q($d->Reset; $d->Dumpxs);
 689   }
 690
 691 ############# 103
 692 ##
 693 if (!$Is_ebcdic) {
 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
 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 }
 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 ##
 744 if (!$Is_ebcdic) {
 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
 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 }
 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
 789 sub z { print "foo\n" }
 790 $c = [ \&z ];
 791
 792 ############# 121
 793 ##
 794   $WANT = <<'EOT';
 795 #$a = $b;
 796 #$c = [
 797 #  $b
 798 #];
 799 EOT
 800
 801 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
 802 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
 803         if $XS;
 804
 805 ############# 127
 806 ##
 807   $WANT = <<'EOT';
 808 #$a = \&b;
 809 #$c = [
 810 #  \&b
 811 #];
 812 EOT
 813
 814 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
 815 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
 816         if $XS;
 817
 818 ############# 133
 819 ##
 820   $WANT = <<'EOT';
 821 #*a = \&b;
 822 #@c = (
 823 #  \&b
 824 #);
 825 EOT
 826
 827 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dump;);
 828 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dumpxs;)
 829         if $XS;
 830
 831 }
 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 }
 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 }