t/library/yaml_dumper.t

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