contrib/perl5/t/lib/dumper.t

   1 #!./perl -w
   2 #
   3 # testsuite for Data::Dumper
   4 #
   5
   6 BEGIN {
   7     chdir 't' if -d 't';
   8     @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   print( ($t eq $WANT and not $@) ? "ok $TNUM\n"
  26         : "not ok $TNUM\n--Expected--\n$WANT\n--Got--\n$@$t\n");
  27
  28   ++$TNUM;
  29   eval "$t";
  30   print $@ ? "not ok $TNUM\n# \$@ says: $@\n" : "ok $TNUM\n";
  31
  32   $t = eval $string;
  33   ++$TNUM;
  34   print( ($t eq $WANT and not $@) ? "ok $TNUM\n"
  35         : "not ok $TNUM\n--Expected--\n$WANT\n--Got--\n$@$t\n");
  36 }
  37
  38 if (defined &Data::Dumper::Dumpxs) {
  39   print "### XS extension loaded, will run XS tests\n";
  40   $TMAX = 162; $XS = 1;
  41 }
  42 else {
  43   print "### XS extensions not loaded, will NOT run XS tests\n";
  44   $TMAX = 81; $XS = 0;
  45 }
  46
  47 print "1..$TMAX\n";
  48
  49 #############
  50 #############
  51
  52 @c = ('c');
  53 $c = \@c;
  54 $b = {};
  55 $a = [1, $b, $c];
  56 $b->{a} = $a;
  57 $b->{b} = $a->[1];
  58 $b->{c} = $a->[2];
  59
  60 ############# 1
  61 ##
  62 $WANT = <<'EOT';
  63 #$a = [
  64 #       1,
  65 #       {
  66 #         'a' => $a,
  67 #         'b' => $a->[1],
  68 #         'c' => [
  69 #                  'c'
  70 #                ]
  71 #       },
  72 #       $a->[1]{'c'}
  73 #     ];
  74 #$b = $a->[1];
  75 #$c = $a->[1]{'c'};
  76 EOT
  77
  78 TEST q(Data::Dumper->Dump([$a,$b,$c], [qw(a b c)]));
  79 TEST q(Data::Dumper->Dumpxs([$a,$b,$c], [qw(a b c)])) if $XS;
  80
  81
  82 ############# 7
  83 ##
  84 $WANT = <<'EOT';
  85 #@a = (
  86 #       1,
  87 #       {
  88 #         'a' => [],
  89 #         'b' => {},
  90 #         'c' => [
  91 #                  'c'
  92 #                ]
  93 #       },
  94 #       []
  95 #     );
  96 #$a[1]{'a'} = \@a;
  97 #$a[1]{'b'} = $a[1];
  98 #$a[2] = $a[1]{'c'};
  99 #$b = $a[1];
 100 EOT
 101
 102 $Data::Dumper::Purity = 1;         # fill in the holes for eval
 103 TEST q(Data::Dumper->Dump([$a, $b], [qw(*a b)])); # print as @a
 104 TEST q(Data::Dumper->Dumpxs([$a, $b], [qw(*a b)])) if $XS;
 105
 106 ############# 13
 107 ##
 108 $WANT = <<'EOT';
 109 #%b = (
 110 #       'a' => [
 111 #                1,
 112 #                {},
 113 #                [
 114 #                  'c'
 115 #                ]
 116 #              ],
 117 #       'b' => {},
 118 #       'c' => []
 119 #     );
 120 #$b{'a'}[1] = \%b;
 121 #$b{'b'} = \%b;
 122 #$b{'c'} = $b{'a'}[2];
 123 #$a = $b{'a'};
 124 EOT
 125
 126 TEST q(Data::Dumper->Dump([$b, $a], [qw(*b a)])); # print as %b
 127 TEST q(Data::Dumper->Dumpxs([$b, $a], [qw(*b a)])) if $XS;
 128
 129 ############# 19
 130 ##
 131 $WANT = <<'EOT';
 132 #$a = [
 133 #  1,
 134 #  {
 135 #    'a' => [],
 136 #    'b' => {},
 137 #    'c' => []
 138 #  },
 139 #  []
 140 #];
 141 #$a->[1]{'a'} = $a;
 142 #$a->[1]{'b'} = $a->[1];
 143 #$a->[1]{'c'} = \@c;
 144 #$a->[2] = \@c;
 145 #$b = $a->[1];
 146 EOT
 147
 148 $Data::Dumper::Indent = 1;
 149 TEST q(
 150        $d = Data::Dumper->new([$a,$b], [qw(a b)]);
 151        $d->Seen({'*c' => $c});
 152        $d->Dump;
 153       );
 154 if ($XS) {
 155   TEST q(
 156          $d = Data::Dumper->new([$a,$b], [qw(a b)]);
 157          $d->Seen({'*c' => $c});
 158          $d->Dumpxs;
 159         );
 160 }
 161
 162
 163 ############# 25
 164 ##
 165 $WANT = <<'EOT';
 166 #$a = [
 167 #       #0
 168 #       1,
 169 #       #1
 170 #       {
 171 #         a => $a,
 172 #         b => $a->[1],
 173 #         c => [
 174 #                #0
 175 #                'c'
 176 #              ]
 177 #       },
 178 #       #2
 179 #       $a->[1]{c}
 180 #     ];
 181 #$b = $a->[1];
 182 EOT
 183
 184 $d->Indent(3);
 185 $d->Purity(0)->Quotekeys(0);
 186 TEST q( $d->Reset; $d->Dump );
 187
 188 TEST q( $d->Reset; $d->Dumpxs ) if $XS;
 189
 190 ############# 31
 191 ##
 192 $WANT = <<'EOT';
 193 #$VAR1 = [
 194 #  1,
 195 #  {
 196 #    'a' => [],
 197 #    'b' => {},
 198 #    'c' => [
 199 #      'c'
 200 #    ]
 201 #  },
 202 #  []
 203 #];
 204 #$VAR1->[1]{'a'} = $VAR1;
 205 #$VAR1->[1]{'b'} = $VAR1->[1];
 206 #$VAR1->[2] = $VAR1->[1]{'c'};
 207 EOT
 208
 209 TEST q(Dumper($a));
 210 TEST q(Data::Dumper::DumperX($a)) if $XS;
 211
 212 ############# 37
 213 ##
 214 $WANT = <<'EOT';
 215 #[
 216 #  1,
 217 #  {
 218 #    a => $VAR1,
 219 #    b => $VAR1->[1],
 220 #    c => [
 221 #      'c'
 222 #    ]
 223 #  },
 224 #  $VAR1->[1]{c}
 225 #]
 226 EOT
 227
 228 {
 229   local $Data::Dumper::Purity = 0;
 230   local $Data::Dumper::Quotekeys = 0;
 231   local $Data::Dumper::Terse = 1;
 232   TEST q(Dumper($a));
 233   TEST q(Data::Dumper::DumperX($a)) if $XS;
 234 }
 235
 236
 237 ############# 43
 238 ##
 239 if (!$Is_ebcdic) {
 240 $WANT = <<'EOT';
 241 #$VAR1 = {
 242 #  "abc\0'\efg" => "mno\0"
 243 #};
 244 EOT
 245 }
 246 else {
 247 $WANT = <<'EOT';
 248 #$VAR1 = {
 249 #  "\201\202\203\340\360'\340\205\206\207" => "\224\225\226\340\360"
 250 #};
 251 EOT
 252 }
 253
 254 $foo = { "abc\000\'\efg" => "mno\000" };
 255 {
 256   local $Data::Dumper::Useqq = 1;
 257   TEST q(Dumper($foo));
 258 }
 259
 260   $WANT = <<"EOT";
 261 #\$VAR1 = {
 262 #  'abc\0\\'\efg' => 'mno\0'
 263 #};
 264 EOT
 265
 266   {
 267     local $Data::Dumper::Useqq = 1;
 268     TEST q(Data::Dumper::DumperX($foo)) if $XS;   # cheat
 269   }
 270
 271
 272
 273 #############
 274 #############
 275
 276 {
 277   package main;
 278   use Data::Dumper;
 279   $foo = 5;
 280   @foo = (10,\*foo);
 281   %foo = (a=>1,b=>\$foo,c=>\@foo);
 282   $foo{d} = \%foo;
 283   $foo[2] = \%foo;
 284
 285 ############# 49
 286 ##
 287   $WANT = <<'EOT';
 288 #$foo = \*::foo;
 289 #*::foo = \5;
 290 #*::foo = [
 291 #           #0
 292 #           10,
 293 #           #1
 294 #           '',
 295 #           #2
 296 #           {
 297 #             'a' => 1,
 298 #             'b' => '',
 299 #             'c' => [],
 300 #             'd' => {}
 301 #           }
 302 #         ];
 303 #*::foo{ARRAY}->[1] = $foo;
 304 #*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
 305 #*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
 306 #*::foo{ARRAY}->[2]{'d'} = *::foo{ARRAY}->[2];
 307 #*::foo = *::foo{ARRAY}->[2];
 308 #@bar = @{*::foo{ARRAY}};
 309 #%baz = %{*::foo{ARRAY}->[2]};
 310 EOT
 311
 312   $Data::Dumper::Purity = 1;
 313   $Data::Dumper::Indent = 3;
 314   TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz']));
 315   TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz'])) if $XS;
 316
 317 ############# 55
 318 ##
 319   $WANT = <<'EOT';
 320 #$foo = \*::foo;
 321 #*::foo = \5;
 322 #*::foo = [
 323 #  10,
 324 #  '',
 325 #  {
 326 #    'a' => 1,
 327 #    'b' => '',
 328 #    'c' => [],
 329 #    'd' => {}
 330 #  }
 331 #];
 332 #*::foo{ARRAY}->[1] = $foo;
 333 #*::foo{ARRAY}->[2]{'b'} = *::foo{SCALAR};
 334 #*::foo{ARRAY}->[2]{'c'} = *::foo{ARRAY};
 335 #*::foo{ARRAY}->[2]{'d'} = *::foo{ARRAY}->[2];
 336 #*::foo = *::foo{ARRAY}->[2];
 337 #$bar = *::foo{ARRAY};
 338 #$baz = *::foo{ARRAY}->[2];
 339 EOT
 340
 341   $Data::Dumper::Indent = 1;
 342   TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
 343   TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
 344
 345 ############# 61
 346 ##
 347   $WANT = <<'EOT';
 348 #@bar = (
 349 #  10,
 350 #  \*::foo,
 351 #  {}
 352 #);
 353 #*::foo = \5;
 354 #*::foo = \@bar;
 355 #*::foo = {
 356 #  'a' => 1,
 357 #  'b' => '',
 358 #  'c' => [],
 359 #  'd' => {}
 360 #};
 361 #*::foo{HASH}->{'b'} = *::foo{SCALAR};
 362 #*::foo{HASH}->{'c'} = \@bar;
 363 #*::foo{HASH}->{'d'} = *::foo{HASH};
 364 #$bar[2] = *::foo{HASH};
 365 #%baz = %{*::foo{HASH}};
 366 #$foo = $bar[1];
 367 EOT
 368
 369   TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\*foo], ['*bar', '*baz', '*foo']));
 370   TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\*foo], ['*bar', '*baz', '*foo'])) if $XS;
 371
 372 ############# 67
 373 ##
 374   $WANT = <<'EOT';
 375 #$bar = [
 376 #  10,
 377 #  \*::foo,
 378 #  {}
 379 #];
 380 #*::foo = \5;
 381 #*::foo = $bar;
 382 #*::foo = {
 383 #  'a' => 1,
 384 #  'b' => '',
 385 #  'c' => [],
 386 #  'd' => {}
 387 #};
 388 #*::foo{HASH}->{'b'} = *::foo{SCALAR};
 389 #*::foo{HASH}->{'c'} = $bar;
 390 #*::foo{HASH}->{'d'} = *::foo{HASH};
 391 #$bar->[2] = *::foo{HASH};
 392 #$baz = *::foo{HASH};
 393 #$foo = $bar->[1];
 394 EOT
 395
 396   TEST q(Data::Dumper->Dump([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo']));
 397   TEST q(Data::Dumper->Dumpxs([\\@foo, \\%foo, \\*foo], ['bar', 'baz', 'foo'])) if $XS;
 398
 399 ############# 73
 400 ##
 401   $WANT = <<'EOT';
 402 #$foo = \*::foo;
 403 #@bar = (
 404 #  10,
 405 #  $foo,
 406 #  {
 407 #    a => 1,
 408 #    b => \5,
 409 #    c => \@bar,
 410 #    d => $bar[2]
 411 #  }
 412 #);
 413 #%baz = %{$bar[2]};
 414 EOT
 415
 416   $Data::Dumper::Purity = 0;
 417   $Data::Dumper::Quotekeys = 0;
 418   TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz']));
 419   TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['*foo', '*bar', '*baz'])) if $XS;
 420
 421 ############# 79
 422 ##
 423   $WANT = <<'EOT';
 424 #$foo = \*::foo;
 425 #$bar = [
 426 #  10,
 427 #  $foo,
 428 #  {
 429 #    a => 1,
 430 #    b => \5,
 431 #    c => $bar,
 432 #    d => $bar->[2]
 433 #  }
 434 #];
 435 #$baz = $bar->[2];
 436 EOT
 437
 438   TEST q(Data::Dumper->Dump([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz']));
 439   TEST q(Data::Dumper->Dumpxs([\\*foo, \\@foo, \\%foo], ['foo', 'bar', 'baz'])) if $XS;
 440
 441 }
 442
 443 #############
 444 #############
 445 {
 446   package main;
 447   @dogs = ( 'Fido', 'Wags' );
 448   %kennel = (
 449             First => \$dogs[0],
 450             Second =>  \$dogs[1],
 451            );
 452   $dogs[2] = \%kennel;
 453   $mutts = \%kennel;
 454   $mutts = $mutts;         # avoid warning
 455
 456 ############# 85
 457 ##
 458 if (!$Is_ebcdic) {
 459   $WANT = <<'EOT';
 460 #%kennels = (
 461 #  First => \'Fido',
 462 #  Second => \'Wags'
 463 #);
 464 #@dogs = (
 465 #  ${$kennels{First}},
 466 #  ${$kennels{Second}},
 467 #  \%kennels
 468 #);
 469 #%mutts = %kennels;
 470 EOT
 471 }
 472 else {
 473   $WANT = <<'EOT';
 474 #%kennels = (
 475 #  Second => \'Wags',
 476 #  First => \'Fido'
 477 #);
 478 #@dogs = (
 479 #  ${$kennels{First}},
 480 #  ${$kennels{Second}},
 481 #  \%kennels
 482 #);
 483 #%mutts = %kennels;
 484 EOT
 485 }
 486
 487   TEST q(
 488          $d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
 489                                 [qw(*kennels *dogs *mutts)] );
 490          $d->Dump;
 491         );
 492   if ($XS) {
 493     TEST q(
 494            $d = Data::Dumper->new([\\%kennel, \\@dogs, $mutts],
 495                                   [qw(*kennels *dogs *mutts)] );
 496            $d->Dumpxs;
 497           );
 498   }
 499
 500 ############# 91
 501 ##
 502   $WANT = <<'EOT';
 503 #%kennels = %kennels;
 504 #@dogs = @dogs;
 505 #%mutts = %kennels;
 506 EOT
 507
 508   TEST q($d->Dump);
 509   TEST q($d->Dumpxs) if $XS;
 510
 511 ############# 97
 512 ##
 513 if (!$Is_ebcdic) {
 514   $WANT = <<'EOT';
 515 #%kennels = (
 516 #  First => \'Fido',
 517 #  Second => \'Wags'
 518 #);
 519 #@dogs = (
 520 #  ${$kennels{First}},
 521 #  ${$kennels{Second}},
 522 #  \%kennels
 523 #);
 524 #%mutts = %kennels;
 525 EOT
 526 }
 527 else {
 528   $WANT = <<'EOT';
 529 #%kennels = (
 530 #  Second => \'Wags',
 531 #  First => \'Fido'
 532 #);
 533 #@dogs = (
 534 #  ${$kennels{First}},
 535 #  ${$kennels{Second}},
 536 #  \%kennels
 537 #);
 538 #%mutts = %kennels;
 539 EOT
 540 }
 541
 542   TEST q($d->Reset; $d->Dump);
 543   if ($XS) {
 544     TEST q($d->Reset; $d->Dumpxs);
 545   }
 546
 547 ############# 103
 548 ##
 549 if (!$Is_ebcdic) {
 550  $WANT = <<'EOT';
 551 #@dogs = (
 552 #  'Fido',
 553 #  'Wags',
 554 #  {
 555 #    First => \$dogs[0],
 556 #    Second => \$dogs[1]
 557 #  }
 558 #);
 559 #%kennels = %{$dogs[2]};
 560 #%mutts = %{$dogs[2]};
 561 EOT
 562 }
 563 else {
 564   $WANT = <<'EOT';
 565 #@dogs = (
 566 #  'Fido',
 567 #  'Wags',
 568 #  {
 569 #    Second => \$dogs[1],
 570 #    First => \$dogs[0]
 571 #  }
 572 #);
 573 #%kennels = %{$dogs[2]};
 574 #%mutts = %{$dogs[2]};
 575 EOT
 576 }
 577
 578   TEST q(
 579          $d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
 580                                 [qw(*dogs *kennels *mutts)] );
 581          $d->Dump;
 582         );
 583   if ($XS) {
 584     TEST q(
 585            $d = Data::Dumper->new([\\@dogs, \\%kennel, $mutts],
 586                                   [qw(*dogs *kennels *mutts)] );
 587            $d->Dumpxs;
 588           );
 589   }
 590
 591 ############# 109
 592 ##
 593   TEST q($d->Reset->Dump);
 594   if ($XS) {
 595     TEST q($d->Reset->Dumpxs);
 596   }
 597
 598 ############# 115
 599 ##
 600 if (!$Is_ebcdic) {
 601   $WANT = <<'EOT';
 602 #@dogs = (
 603 #  'Fido',
 604 #  'Wags',
 605 #  {
 606 #    First => \'Fido',
 607 #    Second => \'Wags'
 608 #  }
 609 #);
 610 #%kennels = (
 611 #  First => \'Fido',
 612 #  Second => \'Wags'
 613 #);
 614 EOT
 615 }
 616 else {
 617   $WANT = <<'EOT';
 618 #@dogs = (
 619 #  'Fido',
 620 #  'Wags',
 621 #  {
 622 #    Second => \'Wags',
 623 #    First => \'Fido'
 624 #  }
 625 #);
 626 #%kennels = (
 627 #  Second => \'Wags',
 628 #  First => \'Fido'
 629 #);
 630 EOT
 631 }
 632
 633   TEST q(
 634          $d = Data::Dumper->new( [\@dogs, \%kennel], [qw(*dogs *kennels)] );
 635          $d->Deepcopy(1)->Dump;
 636         );
 637   if ($XS) {
 638     TEST q($d->Reset->Dumpxs);
 639   }
 640
 641 }
 642
 643 {
 644
 645 sub z { print "foo\n" }
 646 $c = [ \&z ];
 647
 648 ############# 121
 649 ##
 650   $WANT = <<'EOT';
 651 #$a = $b;
 652 #$c = [
 653 #  $b
 654 #];
 655 EOT
 656
 657 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dump;);
 658 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'b' => \&z})->Dumpxs;)
 659         if $XS;
 660
 661 ############# 127
 662 ##
 663   $WANT = <<'EOT';
 664 #$a = \&b;
 665 #$c = [
 666 #  \&b
 667 #];
 668 EOT
 669
 670 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dump;);
 671 TEST q(Data::Dumper->new([\&z,$c],['a','c'])->Seen({'*b' => \&z})->Dumpxs;)
 672         if $XS;
 673
 674 ############# 133
 675 ##
 676   $WANT = <<'EOT';
 677 #*a = \&b;
 678 #@c = (
 679 #  \&b
 680 #);
 681 EOT
 682
 683 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dump;);
 684 TEST q(Data::Dumper->new([\&z,$c],['*a','*c'])->Seen({'*b' => \&z})->Dumpxs;)
 685         if $XS;
 686
 687 }
 688
 689 {
 690   $a = [];
 691   $a->[1] = \$a->[0];
 692
 693 ############# 139
 694 ##
 695   $WANT = <<'EOT';
 696 #@a = (
 697 #  undef,
 698 #  ''
 699 #);
 700 #$a[1] = \$a[0];
 701 EOT
 702
 703 TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dump;);
 704 TEST q(Data::Dumper->new([$a],['*a'])->Purity(1)->Dumpxs;)
 705         if $XS;
 706 }
 707
 708 {
 709   $a = \\\\\'foo';
 710   $b = $$$a;
 711
 712 ############# 145
 713 ##
 714   $WANT = <<'EOT';
 715 #$a = \\\\\'foo';
 716 #$b = ${${$a}};
 717 EOT
 718
 719 TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
 720 TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
 721         if $XS;
 722 }
 723
 724 {
 725   $a = [{ a => \$b }, { b => undef }];
 726   $b = [{ c => \$b }, { d => \$a }];
 727
 728 ############# 151
 729 ##
 730   $WANT = <<'EOT';
 731 #$a = [
 732 #  {
 733 #    a => \[
 734 #        {
 735 #          c => ''
 736 #        },
 737 #        {
 738 #          d => \[]
 739 #        }
 740 #      ]
 741 #  },
 742 #  {
 743 #    b => undef
 744 #  }
 745 #];
 746 #${$a->[0]{a}}->[0]->{c} = $a->[0]{a};
 747 #${${$a->[0]{a}}->[1]->{d}} = $a;
 748 #$b = ${$a->[0]{a}};
 749 EOT
 750
 751 TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dump;);
 752 TEST q(Data::Dumper->new([$a,$b],['a','b'])->Purity(1)->Dumpxs;)
 753         if $XS;
 754 }
 755
 756 {
 757   $a = [[[[\\\\\'foo']]]];
 758   $b = $a->[0][0];
 759   $c = $${$b->[0][0]};
 760
 761 ############# 157
 762 ##
 763   $WANT = <<'EOT';
 764 #$a = [
 765 #  [
 766 #    [
 767 #      [
 768 #        \\\\\'foo'
 769 #      ]
 770 #    ]
 771 #  ]
 772 #];
 773 #$b = $a->[0][0];
 774 #$c = ${${$a->[0][0][0][0]}};
 775 EOT
 776
 777 TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dump;);
 778 TEST q(Data::Dumper->new([$a,$b,$c],['a','b','c'])->Purity(1)->Dumpxs;)
 779         if $XS;
 780 }