ext/Data/Dumper/t/dumper.t

   1 #!./perl -w
   2 #
   3 # testsuite for Data::Dumper
   4 #
   5
   6 BEGIN {
   7     chdir 't' if -d 't';
   8     @INC = '../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 = 192; $XS = 1;
  65 }
  66 else {
  67   print "### XS extensions not loaded, will NOT run XS tests\n";
  68   $TMAX = 96; $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 #         'c' => [
  91 #                  'c'
  92 #                ],
  93 #         'a' => $a,
  94 #         'b' => $a->[1]
  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 #         'c' => [
 113 #                  'c'
 114 #                ],
 115 #         'a' => [],
 116 #         'b' => {}
 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 #       'c' => [
 135 #                'c'
 136 #              ],
 137 #       'a' => [
 138 #                1,
 139 #                {},
 140 #                []
 141 #              ],
 142 #       'b' => {}
 143 #     );
 144 #$b{'a'}[1] = \%b;
 145 #$b{'a'}[2] = $b{'c'};
 146 #$b{'b'} = \%b;
 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 #    'c' => [],
 160 #    'a' => [],
 161 #    'b' => {}
 162 #  },
 163 #  []
 164 #];
 165 #$a->[1]{'c'} = \@c;
 166 #$a->[1]{'a'} = $a;
 167 #$a->[1]{'b'} = $a->[1];
 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 #         c => [
 196 #                #0
 197 #                'c'
 198 #              ],
 199 #         a => $a,
 200 #         b => $a->[1]
 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 #    'c' => [
 221 #      'c'
 222 #    ],
 223 #    'a' => [],
 224 #    'b' => {}
 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 #    c => [
 243 #      'c'
 244 #    ],
 245 #    a => $VAR1,
 246 #    b => $VAR1->[1]
 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 #  "reftest" => \\1,
 266 #  "abc\0'\efg" => "mno\0"
 267 #};
 268 EOT
 269
 270 $foo = { "abc\000\'\efg" => "mno\000",
 271          "reftest" => \\1,
 272        };
 273 {
 274   local $Data::Dumper::Useqq = 1;
 275   TEST q(Dumper($foo));
 276 }
 277
 278   $WANT = <<"EOT";
 279 #\$VAR1 = {
 280 #  'reftest' => \\\\1,
 281 #  'abc\0\\'\efg' => 'mno\0'
 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;
 299   @foo = (-10,\*foo);
 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
 311 #           -10,
 312 #           #1
 313 #           do{my $o},
 314 #           #2
 315 #           {
 316 #             'c' => [],
 317 #             'a' => 1,
 318 #             'b' => do{my $o},
 319 #             'd' => {}
 320 #           }
 321 #         ];
 322 #*::foo{ARRAY}->[1] = $foo;
 323 #*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
 324 #*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
 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 = [
 342 #  -10,
 343 #  do{my $o},
 344 #  {
 345 #    'c' => [],
 346 #    'a' => 1,
 347 #    'b' => do{my $o},
 348 #    'd' => {}
 349 #  }
 350 #];
 351 #*::foo{ARRAY}->[1] = $foo;
 352 #*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
 353 #*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
 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 = (
 368 #  -10,
 369 #  \*::foo,
 370 #  {}
 371 #);
 372 #*::foo = \5;
 373 #*::foo = \@bar;
 374 #*::foo = {
 375 #  'c' => [],
 376 #  'a' => 1,
 377 #  'b' => do{my $o},
 378 #  'd' => {}
 379 #};
 380 #*::foo{HASH}->{'c'} = \@bar;
 381 #*::foo{HASH}->{'b'} = *::foo{SCALAR};
 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 = [
 395 #  -10,
 396 #  \*::foo,
 397 #  {}
 398 #];
 399 #*::foo = \5;
 400 #*::foo = $bar;
 401 #*::foo = {
 402 #  'c' => [],
 403 #  'a' => 1,
 404 #  'b' => do{my $o},
 405 #  'd' => {}
 406 #};
 407 #*::foo{HASH}->{'c'} = $bar;
 408 #*::foo{HASH}->{'b'} = *::foo{SCALAR};
 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 = (
 423 #  -10,
 424 #  $foo,
 425 #  {
 426 #    c => \@bar,
 427 #    a => 1,
 428 #    b => \5,
 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 = [
 445 #  -10,
 446 #  $foo,
 447 #  {
 448 #    c => $bar,
 449 #    a => 1,
 450 #    b => \5,
 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 #  Second => \'Wags',
 480 #  First => \'Fido'
 481 #);
 482 #@dogs = (
 483 #  ${$kennels{First}},
 484 #  ${$kennels{Second}},
 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 #  Second => \'Wags',
 519 #  First => \'Fido'
 520 #);
 521 #@dogs = (
 522 #  ${$kennels{First}},
 523 #  ${$kennels{Second}},
 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 #    Second => \$dogs[1],
 543 #    First => \$dogs[0]
 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 #    Second => \'Wags',
 578 #    First => \'Fido'
 579 #  }
 580 #);
 581 #%kennels = (
 582 #  Second => \'Wags',
 583 #  First => \'Fido'
 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
 599 sub z { print "foo\n" }
 600 $c = [ \&z ];
 601
 602 ############# 121
 603 ##
 604   $WANT = <<'EOT';
 605 #$a = $b;
 606 #$c = [
 607 #  $b
 608 #];
 609 EOT
 610
 611 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
 612 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
 613         if $XS;
 614
 615 ############# 127
 616 ##
 617   $WANT = <<'EOT';
 618 #$a = \&b;
 619 #$c = [
 620 #  \&b
 621 #];
 622 EOT
 623
 624 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
 625 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
 626         if $XS;
 627
 628 ############# 133
 629 ##
 630   $WANT = <<'EOT';
 631 #*a = \&b;
 632 #@c = (
 633 #  \&b
 634 #);
 635 EOT
 636
 637 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dump;);
 638 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dumpxs;)
 639         if $XS;
 640
 641 }
 642
 643 {
 644   $a = [];
 645   $a->[1] = \$a->[0];
 646
 647 ############# 139
 648 ##
 649   $WANT = <<'EOT';
 650 #@a = (
 651 #  undef,
 652 #  do{my $o}
 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 #        {
 689 #          c => do{my $o}
 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 }
 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 }
 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 }
 811
 812 {
 813   $a = "\x{09c10}";
 814 ############# 187
 815 ## XS code was adding an extra \0
 816   $WANT = <<'EOT';
 817 #$a = "\x{9c10}";
 818 EOT
 819
 820   TEST q(Data::Dumper->Dump([$a], ['a']));
 821   TEST q(Data::Dumper->Dumpxs([$a], ['a']));
 822
 823 }