t/library/dumper.t

   1 #!perl
   2 # Copyright (C) 2001-2008, Parrot Foundation.
   3 # $Id$
   4
   5 use strict;
   6 use warnings;
   7 use lib qw( t . lib ../lib ../../lib );
   8
   9 use Test::More;
  10 use Parrot::Test tests => 26;
  11
  12 =head1 NAME
  13
  14 t/library/dumper.t - test dumping of data
  15
  16 =head1 SYNOPSIS
  17
  18     % prove t/library/dumper.t
  19
  20 =head1 DESCRIPTION
  21
  22 Tests data dumping.
  23
  24 =cut
  25
  26 # no. 1
  27 pir_output_is( <<'CODE', <<'OUT', "dumping array of sorted numbers" );
  28
  29 .sub test :main
  30     load_bytecode "dumper.pbc"
  31     .local pmc array
  32
  33     new array, 'ResizablePMCArray'
  34     push array, 0
  35     push array, 1
  36     push array, 2
  37     push array, 3
  38     push array, 4
  39     push array, 5
  40     push array, 6
  41     push array, 7
  42     push array, 8
  43     push array, 9
  44
  45     _dumper( array, "array" )
  46 .end
  47 CODE
  48 "array" => ResizablePMCArray (size:10) [
  49     0,
  50     1,
  51     2,
  52     3,
  53     4,
  54     5,
  55     6,
  56     7,
  57     8,
  58     9
  59 ]
  60 OUT
  61
  62 # no. 2
  63
  64 pir_output_is( <<'CODE', <<'OUT', "dumping unsorted numbers" );
  65 .sub test :main
  66     load_bytecode "dumper.pbc"
  67     .local pmc array
  68
  69     new array, 'ResizablePMCArray'
  70     push array, 6
  71     push array, 1
  72     push array, 8
  73     push array, 3
  74     push array, 2
  75     push array, 9
  76     push array, 7
  77     push array, 4
  78     push array, 0
  79     push array, 5
  80
  81     _dumper( array, "array" )
  82 .end
  83 CODE
  84 "array" => ResizablePMCArray (size:10) [
  85     6,
  86     1,
  87     8,
  88     3,
  89     2,
  90     9,
  91     7,
  92     4,
  93     0,
  94     5
  95 ]
  96 OUT
  97
  98 # no. 3
  99 pir_output_is( <<'CODE', <<'OUT', "dumping sorted strings" );
 100
 101 .sub test :main
 102     load_bytecode "dumper.pbc"
 103     .local pmc array
 104
 105     new array, 'ResizablePMCArray'
 106     push array, "alpha"
 107     push array, "bravo"
 108     push array, "charlie"
 109     push array, "delta"
 110     push array, "echo"
 111     push array, "foxtrot"
 112     push array, "golf"
 113     push array, "hotel"
 114
 115     _dumper( array, "strings" )
 116 .end
 117 CODE
 118 "strings" => ResizablePMCArray (size:8) [
 119     "alpha",
 120     "bravo",
 121     "charlie",
 122     "delta",
 123     "echo",
 124     "foxtrot",
 125     "golf",
 126     "hotel"
 127 ]
 128 OUT
 129
 130 # no. 4
 131 pir_output_is( <<'CODE', <<'OUT', "sorting unsorted strings" );
 132
 133 .sub test :main
 134     load_bytecode "dumper.pbc"
 135     .local pmc array
 136
 137     new array, 'ResizablePMCArray'
 138     push array, "charlie"
 139     push array, "hotel"
 140     push array, "alpha"
 141     push array, "delta"
 142     push array, "foxtrot"
 143     push array, "golf"
 144     push array, "bravo"
 145     push array, "echo"
 146
 147     _dumper( array, "strings" )
 148 .end
 149 CODE
 150 "strings" => ResizablePMCArray (size:8) [
 151     "charlie",
 152     "hotel",
 153     "alpha",
 154     "delta",
 155     "foxtrot",
 156     "golf",
 157     "bravo",
 158     "echo"
 159 ]
 160 OUT
 161
 162 # no. 5
 163 pir_output_is( <<'CODE', <<'OUT', "dumping different types" );
 164
 165 .sub test :main
 166     load_bytecode "dumper.pbc"
 167     .local pmc array
 168
 169     new array, 'ResizablePMCArray'
 170     push array, 0.1
 171     push array, "charlie"
 172     push array, 2
 173     push array, "hotel"
 174     push array, 5
 175     push array, "alpha"
 176     push array, 0.2
 177     push array, "delta"
 178     push array, 4
 179     push array, "foxtrot"
 180     push array, 0.5
 181     push array, 0.4
 182     push array, 1
 183     push array, "golf"
 184     push array, 0.3
 185     push array, 3
 186     push array, "bravo"
 187     push array, 0.0
 188     push array, 0
 189     push array, "echo"
 190
 191     _dumper( array, "array" )
 192 .end
 193 CODE
 194 "array" => ResizablePMCArray (size:20) [
 195     0.1,
 196     "charlie",
 197     2,
 198     "hotel",
 199     5,
 200     "alpha",
 201     0.2,
 202     "delta",
 203     4,
 204     "foxtrot",
 205     0.5,
 206     0.4,
 207     1,
 208     "golf",
 209     0.3,
 210     3,
 211     "bravo",
 212     0,
 213     0,
 214     "echo"
 215 ]
 216 OUT
 217
 218 # no. 6
 219 pir_output_is( <<'CODE', <<'OUT', "dumping complex data" );
 220
 221 .sub test :main
 222     load_bytecode "dumper.pbc"
 223     .local pmc hash1
 224     .local pmc hash2
 225     .local pmc hash3
 226     .local pmc array1
 227     .local pmc array2
 228
 229     new hash1, 'Hash'
 230     new hash2, 'Hash'
 231     new hash3, 'Hash'
 232     new array1, 'ResizablePMCArray'
 233     new array2, 'ResizablePMCArray'
 234
 235     _dumper( hash1,"hash1" )
 236
 237     $S0 = "hello"
 238     $S1 = "world"
 239     set hash1[$S0], $S1
 240
 241     _dumper( hash1,"hash1" )
 242
 243     $S0 = "hello2"
 244     $S1 = "world2"
 245     set hash1[$S0], $S1
 246
 247     _dumper( hash1,"hash1" )
 248
 249     $S0 = "hash2"
 250     set hash1[$S0], hash2
 251
 252     _dumper( hash1,"hash1" )
 253
 254     $S0 = "hello3"
 255     $S1 = "world3"
 256     set hash2[$S0], $S1
 257
 258     _dumper( hash1,"hash1" )
 259
 260     $S0 = "name"
 261     $S1 = "parrot"
 262     set hash3[$S0], $S1
 263     $S0 = "is"
 264     $S1 = "cool"
 265     set hash3[$S0], $S1
 266
 267     push array1, "this"
 268     push array1, "is"
 269     push array1, "a"
 270     push array1, "test"
 271     push array1, hash3
 272
 273     $S0 = "array1"
 274     set hash2[$S0], array1
 275
 276     _dumper( hash1,"hash1" )
 277
 278 .end
 279 CODE
 280 "hash1" => Hash {
 281 }
 282 "hash1" => Hash {
 283     "hello" => "world"
 284 }
 285 "hash1" => Hash {
 286     "hello" => "world",
 287     "hello2" => "world2"
 288 }
 289 "hash1" => Hash {
 290     "hash2" => Hash {
 291     },
 292     "hello" => "world",
 293     "hello2" => "world2"
 294 }
 295 "hash1" => Hash {
 296     "hash2" => Hash {
 297         "hello3" => "world3"
 298     },
 299     "hello" => "world",
 300     "hello2" => "world2"
 301 }
 302 "hash1" => Hash {
 303     "hash2" => Hash {
 304         "array1" => ResizablePMCArray (size:5) [
 305             "this",
 306             "is",
 307             "a",
 308             "test",
 309             Hash {
 310                 "is" => "cool",
 311                 "name" => "parrot"
 312             }
 313         ],
 314         "hello3" => "world3"
 315     },
 316     "hello" => "world",
 317     "hello2" => "world2"
 318 }
 319 OUT
 320
 321 # no.7
 322 pir_output_is( <<'CODE', <<'OUT', "properties" );
 323
 324 .sub test :main
 325     load_bytecode "dumper.pbc"
 326     .local pmc str
 327     .local pmc array
 328
 329     new array, 'ResizablePMCArray'
 330     push array, "test1"
 331     push array, "test2"
 332
 333     new str, 'String'
 334     set str, "value1"
 335     setprop array, "key1", str
 336
 337     new str, 'String'
 338     set str, "value2"
 339     setprop array, "key2", str
 340
 341     _dumper( array )
 342
 343 .end
 344 CODE
 345 "VAR1" => ResizablePMCArray (size:2) [
 346     "test1",
 347     "test2"
 348 ] with-properties: Hash {
 349     "key1" => "value1",
 350     "key2" => "value2"
 351 }
 352 OUT
 353
 354 # no. 8
 355 pir_output_is( <<'CODE', <<'OUT', "indent string" );
 356
 357 .sub test :main
 358     load_bytecode "dumper.pbc"
 359     .local pmc hash1
 360     .local pmc hash2
 361     .local pmc array1
 362     .local pmc array2
 363     .local string name
 364     .local string indent
 365
 366     new hash1, 'Hash'
 367     new hash2, 'Hash'
 368     new array1, 'ResizablePMCArray'
 369     new array2, 'ResizablePMCArray'
 370
 371     set hash1["hash2"], hash2
 372     set hash2["array"], array1
 373     set hash1["test1"], "test1"
 374     set hash2["test2"], "test2"
 375     push array1, 1
 376     push array1, array2
 377     push array2, "test"
 378     setprop hash1, "array2", array2
 379     name = "hash"
 380     indent = "|  "
 381     _dumper( hash1, name, indent )
 382     _dumper( hash1, name, indent )
 383     print "name = '"
 384     print name
 385     print "'\nindent = '"
 386     print indent
 387     print "'\n"
 388 .end
 389 CODE
 390 "hash" => Hash {
 391 |  "hash2" => Hash {
 392 |  |  "array" => ResizablePMCArray (size:2) [
 393 |  |  |  1,
 394 |  |  |  ResizablePMCArray (size:1) [
 395 |  |  |  |  "test"
 396 |  |  |  ]
 397 |  |  ],
 398 |  |  "test2" => "test2"
 399 |  },
 400 |  "test1" => "test1"
 401 } with-properties: Hash {
 402 |  "array2" => \hash["hash2"]["array"][1]
 403 }
 404 "hash" => Hash {
 405 |  "hash2" => Hash {
 406 |  |  "array" => ResizablePMCArray (size:2) [
 407 |  |  |  1,
 408 |  |  |  ResizablePMCArray (size:1) [
 409 |  |  |  |  "test"
 410 |  |  |  ]
 411 |  |  ],
 412 |  |  "test2" => "test2"
 413 |  },
 414 |  "test1" => "test1"
 415 } with-properties: Hash {
 416 |  "array2" => \hash["hash2"]["array"][1]
 417 }
 418 name = 'hash'
 419 indent = '|  '
 420 OUT
 421
 422 # no. 9
 423 pir_output_is( <<'CODE', <<'OUT', "back-referencing properties" );
 424
 425 .sub test :main
 426     load_bytecode "dumper.pbc"
 427     .local pmc hash
 428
 429     new hash, 'Hash'
 430
 431     set hash["hello"], "world"
 432     setprop hash, "backref", hash
 433     _dumper( hash )
 434 .end
 435 CODE
 436 "VAR1" => Hash {
 437     "hello" => "world"
 438 } with-properties: Hash {
 439     "backref" => \VAR1
 440 }
 441 OUT
 442
 443 # no. 10
 444 pir_output_is( <<'CODE', <<'OUT', "self-referential properties (1)" );
 445
 446 .sub test :main
 447     load_bytecode "dumper.pbc"
 448     .local pmc hash
 449     .local pmc prop
 450
 451     new hash, 'Hash'
 452
 453     set hash["hello"], "world"
 454     setprop hash, "self", hash
 455     prophash prop, hash
 456     setprop hash, "self", prop
 457     _dumper( hash )
 458 .end
 459 CODE
 460 "VAR1" => Hash {
 461     "hello" => "world"
 462 } with-properties: Hash {
 463     "self" => \VAR1.properties()
 464 }
 465 OUT
 466
 467 # no. 11
 468 pir_output_is( <<'CODE', <<'OUT', "self-referential properties (2)" );
 469
 470 .sub test :main
 471     load_bytecode "dumper.pbc"
 472     .local pmc array
 473     .local pmc hash1
 474     .local pmc hash2
 475     .local pmc prop
 476
 477     new array, 'ResizablePMCArray'
 478     new hash1, 'Hash'
 479     new hash2, 'Hash'
 480
 481     set hash1["hello1"], "world1"
 482     set hash2["hello2"], "world2"
 483     setprop hash1, "das leben", hash2
 484     prophash prop, hash1
 485     set prop["das leben"], "ist schoen"
 486     setprop hash2, "hash1prop", prop
 487     push array, hash1
 488     push array, hash2
 489     push array, prop
 490     prophash prop, hash2
 491     push array, prop
 492     _dumper( array )
 493 .end
 494 CODE
 495 "VAR1" => ResizablePMCArray (size:4) [
 496     Hash {
 497         "hello1" => "world1"
 498     } with-properties: Hash {
 499         "das leben" => "ist schoen"
 500     },
 501     Hash {
 502         "hello2" => "world2"
 503     } with-properties: Hash {
 504         "hash1prop" => \VAR1[0].properties()
 505     },
 506     \VAR1[0].properties(),
 507     \VAR1[1].properties()
 508 ]
 509 OUT
 510
 511 # no. 12
 512 pir_output_is( <<'CODE', <<'OUT', "dumping objects" );
 513
 514 .sub test :main
 515     load_bytecode "dumper.pbc"
 516     .local pmc temp
 517     .local pmc array
 518
 519     newclass temp, "TestClass"
 520
 521     new array, 'ResizablePMCArray'
 522     temp = new "TestClass"
 523     push array, temp
 524     $P0 = get_class 'TestClass'
 525     temp = new $P0
 526     push array, temp
 527
 528     _dumper( array )
 529 .end
 530
 531 .namespace ["TestClass"]
 532
 533 .sub __dump :method
 534     .param pmc dumper
 535     .param string dname
 536     .local string subindent
 537     .local string indent
 538     .local string name
 539
 540     (subindent, indent) = dumper."newIndent"()
 541     print "{\n"
 542
 543     print subindent
 544     print "this is\n"
 545
 546     print subindent
 547     print "_"
 548     typeof name, self
 549     print name
 550     print "::__dump\n"
 551
 552     print indent
 553     print "}"
 554
 555     dumper."deleteIndent"()
 556
 557     .begin_return
 558     .end_return
 559 .end
 560 .namespace []
 561 CODE
 562 "VAR1" => ResizablePMCArray (size:2) [
 563     PMC 'TestClass' {
 564         this is
 565         _TestClass::__dump
 566     },
 567     PMC 'TestClass' {
 568         this is
 569         _TestClass::__dump
 570     }
 571 ]
 572 OUT
 573
 574 # no. 13
 575 pir_output_is( <<'CODE', <<'OUT', "dumping 'null'" );
 576
 577 .sub test :main
 578     load_bytecode "dumper.pbc"
 579     .local pmc array
 580     .local pmc temp
 581
 582     new array, 'ResizablePMCArray'
 583
 584     push array, 0
 585     push array, "0"
 586
 587     null temp
 588     push array, temp
 589
 590     new temp, 'Integer'
 591     set temp, 0
 592     push array, temp
 593
 594     new temp, 'String'
 595     set temp, "0"
 596     push array, temp
 597
 598     _dumper( array, "array" )
 599 .end
 600 CODE
 601 "array" => ResizablePMCArray (size:5) [
 602     0,
 603     "0",
 604     null,
 605     0,
 606     "0"
 607 ]
 608 OUT
 609
 610 # no. 14
 611 pir_output_is( << 'CODE', << 'OUT', "dumping strings" );
 612
 613 .sub _test :main
 614     load_bytecode "dumper.pbc"
 615     .local pmc array
 616     array = new 'ResizablePMCArray'
 617
 618     .local pmc pmc_string, pmc_perl_string
 619     .local string string_1
 620
 621     pmc_string = new 'String'
 622     pmc_string = "This is a String PMC"
 623     push array, pmc_string
 624
 625     pmc_perl_string = new 'String'
 626     pmc_perl_string = "This is a String PMC"
 627     push array, pmc_perl_string
 628
 629     string_1 = "This is a String"
 630     push array, string_1
 631
 632     _dumper( array, "array of various strings" )
 633 .end
 634 CODE
 635 "array of various strings" => ResizablePMCArray (size:3) [
 636     "This is a String PMC",
 637     "This is a String PMC",
 638     "This is a String"
 639 ]
 640 OUT
 641
 642 # no. 15
 643 pir_output_is( <<'CODE', <<'OUT', "dumping complex data in Hash" );
 644
 645 .sub test :main
 646     load_bytecode "dumper.pbc"
 647     .local pmc hash1
 648     .local pmc hash2
 649     .local pmc hash3
 650     .local pmc array1
 651
 652     new hash1, 'Hash'
 653     new hash2, 'Hash'
 654     new hash3, 'Hash'
 655     new array1, 'ResizablePMCArray'
 656
 657     _dumper( hash1,"hash1" )
 658
 659     $S0 = "hello"
 660     $S1 = "world"
 661     set hash1[$S0], $S1
 662
 663     _dumper( hash1,"hash1" )
 664
 665     $S0 = "hello2"
 666     $S1 = "world2"
 667     set hash1[$S0], $S1
 668
 669     _dumper( hash1,"hash1" )
 670
 671     $S0 = "hash2"
 672     set hash1[$S0], hash2
 673
 674     _dumper( hash1,"hash1" )
 675
 676     $S0 = "hello3"
 677     $S1 = "world3"
 678     set hash2[$S0], $S1
 679
 680     _dumper( hash1,"hash1" )
 681
 682     $S0 = "name"
 683     $S1 = "parrot"
 684     set hash3[$S0], $S1
 685     $S0 = "is"
 686     $S1 = "cool"
 687     set hash3[$S0], $S1
 688
 689     array1 = 5
 690     array1[0] = "this"
 691     array1[1] = "is"
 692     array1[2] = "a"
 693     array1[3] = "test"
 694     array1[4] = hash3
 695
 696     $S0 = "array1"
 697     set hash2[$S0], array1
 698
 699     _dumper( hash1,"hash1" )
 700
 701 .end
 702 CODE
 703 "hash1" => Hash {
 704 }
 705 "hash1" => Hash {
 706     "hello" => "world"
 707 }
 708 "hash1" => Hash {
 709     "hello" => "world",
 710     "hello2" => "world2"
 711 }
 712 "hash1" => Hash {
 713     "hash2" => Hash {
 714     },
 715     "hello" => "world",
 716     "hello2" => "world2"
 717 }
 718 "hash1" => Hash {
 719     "hash2" => Hash {
 720         "hello3" => "world3"
 721     },
 722     "hello" => "world",
 723     "hello2" => "world2"
 724 }
 725 "hash1" => Hash {
 726     "hash2" => Hash {
 727         "array1" => ResizablePMCArray (size:5) [
 728             "this",
 729             "is",
 730             "a",
 731             "test",
 732             Hash {
 733                 "is" => "cool",
 734                 "name" => "parrot"
 735             }
 736         ],
 737         "hello3" => "world3"
 738     },
 739     "hello" => "world",
 740     "hello2" => "world2"
 741 }
 742 OUT
 743
 744 # no. 16
 745 pir_output_is( <<'CODE', <<'OUTPUT', "dumping Integer PMC" );
 746
 747 .sub test :main
 748     load_bytecode "dumper.pbc"
 749     .local pmc int1
 750
 751     new int1, 'Integer'
 752     int1 = 12345
 753     _dumper( int1, "Int:" )
 754 .end
 755 CODE
 756 "Int:" => 12345
 757 OUTPUT
 758
 759 # no. 17
 760 pir_output_is( <<'CODE', <<'OUTPUT', "dumping Float PMC" );
 761
 762 .sub test :main
 763     load_bytecode "dumper.pbc"
 764     .local pmc float1
 765
 766     new float1, 'Float'
 767     float1 = 12345.678
 768     _dumper( float1, "Float:" )
 769 .end
 770 CODE
 771 "Float:" => 12345.678
 772 OUTPUT
 773
 774 # no. 18
 775 pir_output_is( <<'CODE', <<'OUTPUT', "dumping ResizablePMCArray PMC" );
 776 .sub test :main
 777     load_bytecode "dumper.pbc"
 778     .local pmc array
 779
 780     new array, 'ResizablePMCArray'
 781     push array, 12345
 782     push array, "hello"
 783     _dumper( array, "array:" )
 784 .end
 785 CODE
 786 "array:" => ResizablePMCArray (size:2) [
 787     12345,
 788     "hello"
 789 ]
 790 OUTPUT
 791
 792 # no. 19
 793 pir_output_is( <<'CODE', <<'OUTPUT', "dumping ResizableStringArray PMC" );
 794 .sub test :main
 795     load_bytecode "dumper.pbc"
 796     .local pmc array
 797
 798     new array, 'ResizableStringArray'
 799     push array, "hello"
 800     push array, "world"
 801     _dumper( array, "array:" )
 802 .end
 803 CODE
 804 "array:" => ResizableStringArray (size:2) [
 805     "hello",
 806     "world"
 807 ]
 808 OUTPUT
 809
 810 # no. 20
 811 pir_output_is( <<'CODE', <<'OUTPUT', "dumping ResizableIntegerArray PMC" );
 812 .sub test :main
 813     load_bytecode "dumper.pbc"
 814     .local pmc array
 815
 816     new array, 'ResizableIntegerArray'
 817     push array, 12345
 818     push array, 67890
 819     _dumper( array, "array:" )
 820 .end
 821 CODE
 822 "array:" => ResizableIntegerArray (size:2) [
 823     12345,
 824     67890
 825 ]
 826 OUTPUT
 827
 828 # no. 21
 829 pir_output_is( <<'CODE', <<'OUTPUT', "dumping ResizableFloatArray PMC" );
 830 .sub test :main
 831     load_bytecode "dumper.pbc"
 832     .local pmc array
 833
 834     new array, 'ResizableFloatArray'
 835     push array, 123.45
 836     push array, 67.89
 837     _dumper( array, "array:" )
 838 .end
 839 CODE
 840 "array:" => ResizableFloatArray (size:2) [
 841     123.45,
 842     67.89
 843 ]
 844 OUTPUT
 845
 846 # no. 22
 847 pir_output_is( <<'CODE', <<'OUTPUT', "dumping FixedPMCArray PMC" );
 848 .sub test :main
 849     load_bytecode "dumper.pbc"
 850     .local pmc array
 851
 852     new array, 'FixedPMCArray'
 853     array = 2
 854     array[0] = 12345
 855     array[1] = "hello"
 856     _dumper( array, "array:" )
 857 .end
 858 CODE
 859 "array:" => FixedPMCArray (size:2) [
 860     12345,
 861     "hello"
 862 ]
 863 OUTPUT
 864
 865 # no. 23
 866 pir_output_is( <<'CODE', <<'OUTPUT', "dumping FixedStringArray PMC" );
 867 .sub test :main
 868     load_bytecode "dumper.pbc"
 869     .local pmc array
 870
 871     new array, 'FixedStringArray'
 872     array = 2
 873     array[0] = "hello"
 874     array[1] = "world"
 875     _dumper( array, "array:" )
 876 .end
 877 CODE
 878 "array:" => FixedStringArray (size:2) [
 879     "hello",
 880     "world"
 881 ]
 882 OUTPUT
 883
 884 # no. 24
 885 pir_output_is( <<'CODE', <<'OUTPUT', "dumping FixedIntegerArray PMC" );
 886 .sub test :main
 887     load_bytecode "dumper.pbc"
 888     .local pmc array
 889
 890     new array, 'FixedIntegerArray'
 891     array = 2
 892     array[0] = 12345
 893     array[1] = 67890
 894     _dumper( array, "array:" )
 895 .end
 896 CODE
 897 "array:" => FixedIntegerArray (size:2) [
 898     12345,
 899     67890
 900 ]
 901 OUTPUT
 902
 903 # no. 25
 904 pir_output_is( <<'CODE', <<'OUTPUT', "dumping FixedFloatArray PMC" );
 905 .sub test :main
 906     load_bytecode "dumper.pbc"
 907     .local pmc array
 908
 909     new array, 'FixedFloatArray'
 910     array = 2
 911     array[0] = 123.45
 912     array[1] = 67.89
 913     _dumper( array, "array:" )
 914 .end
 915 CODE
 916 "array:" => FixedFloatArray (size:2) [
 917     123.45,
 918     67.89
 919 ]
 920 OUTPUT
 921
 922 # no. 26 - Deleted --leo
 923
 924 # no. 27
 925 pir_output_is( <<'CODE', <<'OUTPUT', "custom dumper" );
 926 .sub main :main
 927     load_bytecode "dumper.pbc"
 928     .local pmc o, cl
 929     cl = subclass 'ResizablePMCArray', 'bar'
 930     o = new cl
 931     _dumper(o)
 932 .end
 933
 934 .namespace ["bar"]
 935 .sub init :vtable :method
 936     .local pmc ar
 937     ar = getattribute self, ['ResizablePMCArray'], 'proxy'
 938     push ar, 1
 939     push ar, 2
 940 .end
 941
 942 .sub __dump :method
 943     .param pmc dumper
 944     .param string label
 945     print " __value => {\n"
 946     .local pmc ar
 947     ar = getattribute self, ['ResizablePMCArray'], 'proxy'
 948     dumper.'dump'('attr', ar)
 949     print "\n}"
 950 .end
 951 .namespace []
 952
 953 CODE
 954 "VAR1" => PMC 'bar'  __value => {
 955 ResizablePMCArray (size:2) [
 956     1,
 957     2
 958 ]
 959 }
 960 OUTPUT
 961
 962 # pir_output_is(<<'CODE', <<'OUTPUT', "dumping IntegerArray PMC");
 963 # pir_output_is(<<'CODE', <<'OUTPUT', "dumping FloatValArray PMC");
 964
 965 # Local Variables:
 966 #   mode: cperl
 967 #   cperl-indent-level: 4
 968 #   fill-column: 100
 969 # End:
 970 # vim: expandtab shiftwidth=4: