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     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     }
  14 }
  15
  16 use Data::Dumper;
  17 use Config;
  18 my $Is_ebcdic = defined($Config{'ebcdic'}) && $Config{'ebcdic'} eq 'define';
  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;
  30   $t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
  31       if ($WANT =~ /deadbeef/);
  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   }
  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;
  49   $t =~ s/([A-Z]+)\(0x[0-9a-f]+\)/$1(0xdeadbeef)/g
  50       if ($WANT =~ /deadbeef/);
  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   }
  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";
  64   $TMAX = 186; $XS = 1;
  65 }
  66 else {
  67   print "### XS extensions not loaded, will NOT run XS tests\n";
  68   $TMAX = 93; $XS = 0;
  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 = {
 265 #  "abc\0'\efg" => "mno\0"
 266 #};
 267 EOT
 268
 269 $foo = { "abc\000\'\efg" => "mno\000" };
 270 {
 271   local $Data::Dumper::Useqq = 1;
 272   TEST q(Dumper($foo));
 273 }
 274
 275   $WANT = <<"EOT";
 276 #\$VAR1 = {
 277 #  'abc\0\\'\efg' => 'mno\0'
 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;
 295   @foo = (-10,\*foo);
 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
 307 #           -10,
 308 #           #1
 309 #           do{my $o},
 310 #           #2
 311 #           {
 312 #             'a' => 1,
 313 #             'b' => do{my $o},
 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 = [
 338 #  -10,
 339 #  do{my $o},
 340 #  {
 341 #    'a' => 1,
 342 #    'b' => do{my $o},
 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 = (
 364 #  -10,
 365 #  \*::foo,
 366 #  {}
 367 #);
 368 #*::foo = \5;
 369 #*::foo = \@bar;
 370 #*::foo = {
 371 #  'a' => 1,
 372 #  'b' => do{my $o},
 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 = [
 391 #  -10,
 392 #  \*::foo,
 393 #  {}
 394 #];
 395 #*::foo = \5;
 396 #*::foo = $bar;
 397 #*::foo = {
 398 #  'a' => 1,
 399 #  'b' => do{my $o},
 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 = (
 419 #  -10,
 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 = [
 441 #  -10,
 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 = (
 479 #  ${$kennels{First}},
 480 #  ${$kennels{Second}},
 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 = (
 518 #  ${$kennels{First}},
 519 #  ${$kennels{Second}},
 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
 595 sub z { print "foo\n" }
 596 $c = [ \&z ];
 597
 598 ############# 121
 599 ##
 600   $WANT = <<'EOT';
 601 #$a = $b;
 602 #$c = [
 603 #  $b
 604 #];
 605 EOT
 606
 607 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
 608 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
 609         if $XS;
 610
 611 ############# 127
 612 ##
 613   $WANT = <<'EOT';
 614 #$a = \&b;
 615 #$c = [
 616 #  \&b
 617 #];
 618 EOT
 619
 620 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
 621 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
 622         if $XS;
 623
 624 ############# 133
 625 ##
 626   $WANT = <<'EOT';
 627 #*a = \&b;
 628 #@c = (
 629 #  \&b
 630 #);
 631 EOT
 632
 633 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dump;);
 634 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dumpxs;)
 635         if $XS;
 636
 637 }
 638
 639 {
 640   $a = [];
 641   $a->[1] = \$a->[0];
 642
 643 ############# 139
 644 ##
 645   $WANT = <<'EOT';
 646 #@a = (
 647 #  undef,
 648 #  do{my $o}
 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 #        {
 685 #          c => do{my $o}
 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 }
 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 }
 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 }