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