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