t/pmc/orderedhash.t

   1 #! perl
   2 # Copyright (C) 2001-2006, Parrot Foundation.
   3 # $Id$
   4
   5 use strict;
   6 use warnings;
   7 use lib qw( . lib ../lib ../../lib );
   8 use Test::More;
   9 use Parrot::Test tests => 23;
  10
  11 =head1 NAME
  12
  13 t/pmc/orderedhash.t - Ordered Hash
  14
  15 =head1 SYNOPSIS
  16
  17     % prove t/pmc/orderedhash.t
  18
  19 =head1 DESCRIPTION
  20
  21 Tests the C<OrderedHash> PMC.
  22
  23 =cut
  24
  25 pasm_output_is( <<'CODE', <<OUT, "init" );
  26     new P0, ['OrderedHash']
  27     print "ok 1\n"
  28     set I0, P0
  29     eq I0, 0, ok2
  30     print "not "
  31 ok2:print "ok 2\n"
  32     end
  33 CODE
  34 ok 1
  35 ok 2
  36 OUT
  37
  38 pasm_output_is( <<'CODE', <<OUT, "set keys, get idx" );
  39     new P0, ['OrderedHash']
  40     new P1, ['String']
  41     set P1, "ok 1\n"
  42     set P0["x"], P1
  43     new P1, ['String']
  44     set P1, "ok 2\n"
  45     set P0["a"], P1
  46     new P1, ['String']
  47     set P1, "ok 3\n"
  48     set P0["j"], P1
  49
  50     set I0, P0
  51     eq I0, 3, ok
  52     print "not "
  53 ok: print "ok\n"
  54
  55     set P3, P0[0]
  56     print P3
  57     set P3, P0[1]
  58     print P3
  59     set P3, P0[2]
  60     print P3
  61
  62     set P3, P0["j"]
  63     print P3
  64     set P3, P0["x"]
  65     print P3
  66     set P3, P0["a"]
  67     print P3
  68     end
  69 CODE
  70 ok
  71 ok 1
  72 ok 2
  73 ok 3
  74 ok 3
  75 ok 1
  76 ok 2
  77 OUT
  78
  79 pasm_output_is( <<'CODE', <<OUT, "iterate" );
  80     .include "iterator.pasm"
  81     new P0, ['OrderedHash']
  82     new P1, ['String']
  83     set P1, "ok 1\n"
  84     set P0["x"], P1
  85     new P1, ['String']
  86     set P1, "ok 2\n"
  87     set P0["a"], P1
  88     new P1, ['String']
  89     set P1, "ok 3\n"
  90     set P0["j"], P1
  91
  92     iter P2, P0
  93     set P2, .ITERATE_FROM_START
  94 iter_loop:
  95     unless P2, end_iter
  96     shift P3, P2
  97     set P4, P0[P3]
  98     print P4
  99     branch iter_loop
 100 end_iter:
 101
 102     set P2, .ITERATE_FROM_END
 103 iter_loop2:
 104     unless P2, end_iter2
 105     pop P3, P2
 106     set P4, P0[P3]
 107     print P4
 108     branch iter_loop2
 109 end_iter2:
 110     end
 111 CODE
 112 ok 1
 113 ok 2
 114 ok 3
 115 ok 3
 116 ok 2
 117 ok 1
 118 OUT
 119
 120 pasm_output_is( <<'CODE', <<OUT, "idx only" );
 121     new P0, ['OrderedHash']
 122     new P1, ['String']
 123     set P1, "ok 1\n"
 124     set P0[0], P1
 125     new P1, ['String']
 126     set P1, "ok 2\n"
 127     set P0[1], P1
 128
 129     set P2, P0[0]
 130     print P2
 131     set P2, P0[1]
 132     print P2
 133     end
 134 CODE
 135 ok 1
 136 ok 2
 137 OUT
 138
 139 pasm_output_is( <<'CODE', <<OUT, "set keys, get idx - cloned" );
 140     new P10, ['OrderedHash']
 141     new P1, ['String']
 142     set P1, "ok 1\n"
 143     set P10["x"], P1
 144     new P1, ['String']
 145     set P1, "ok 2\n"
 146     set P10["a"], P1
 147     new P1, ['String']
 148     set P1, "ok 3\n"
 149     set P10["j"], P1
 150
 151     clone P0, P10
 152
 153     set I0, P0
 154     eq I0, 3, ok
 155     print "not "
 156 ok: print "ok\n"
 157
 158     set P3, P0[0]
 159     print P3
 160     set P3, P0[1]
 161     print P3
 162     set P3, P0[2]
 163     print P3
 164
 165     set P3, P0["j"]
 166     print P3
 167     set P3, P0["x"]
 168     print P3
 169     set P3, P0["a"]
 170     print P3
 171
 172     set P3, P0[-1]
 173     print P3
 174     set P3, P0[-2]
 175     print P3
 176     set P3, P0[-3]
 177     print P3
 178     end
 179
 180 CODE
 181 ok
 182 ok 1
 183 ok 2
 184 ok 3
 185 ok 3
 186 ok 1
 187 ok 2
 188 ok 3
 189 ok 2
 190 ok 1
 191 OUT
 192
 193 pasm_output_is( <<'CODE', <<OUT, "exists_keyed" );
 194     new P0, ['OrderedHash']
 195     new P1, ['Integer']
 196     set P0["key"], P1
 197     exists I0, P0["key"]
 198     print I0
 199     exists I0, P0[0]
 200     print I0
 201     exists I0, P0["nokey"]
 202     print I0
 203     exists I0, P0[1]
 204     print I0
 205     new P1, ['Key']
 206     set P1, 0
 207     exists I0, P0[P1]
 208     print I0
 209     set P1, 1
 210     exists I0, P0[P1]
 211     print I0
 212     print "\n"
 213     end
 214 CODE
 215 110010
 216 OUT
 217
 218 pasm_output_is( <<'CODE', <<OUT, "defined_keyed" );
 219     new P0, ['OrderedHash']
 220     new P1, ['Undef']
 221     set P0["key"], P1
 222     defined I0, P0["key"]
 223     print I0
 224     defined I0, P0[0]
 225     print I0
 226     defined I0, P0["nokey"]
 227     print I0
 228     defined I0, P0[1]
 229     print I0
 230     new P2, ['Key']
 231     set P2, 0
 232     defined I0, P0[P2]
 233     print I0
 234     set P2, 1
 235     defined I0, P0[P2]
 236     print I0
 237
 238     set P1, 0
 239     defined I0, P0["key"]
 240     print I0
 241     defined I0, P0[0]
 242     print I0
 243     new P3, ['Key']
 244     set P3, 0
 245     defined I0, P0[P3]
 246     print I0
 247     set P3, 1
 248     defined I0, P0[P3]
 249     print I0
 250     print "\n"
 251     end
 252 CODE
 253 0000001110
 254 OUT
 255
 256 pasm_output_is( <<'CODE', <<OUT, "delete" );
 257     .include "iterator.pasm"
 258     new P0, ['OrderedHash']
 259     new P1, ['String']
 260     set P1, "ok 1\n"
 261     set P0["x"], P1
 262     new P1, ['String']
 263     set P1, "ok 2\n"
 264     set P0["a"], P1
 265     new P1, ['String']
 266     set P1, "ok 3\n"
 267     set P0["j"], P1
 268
 269     delete P0["a"]
 270
 271     iter P2, P0
 272     set P2, .ITERATE_FROM_START_KEYS
 273 iter_loop:
 274     unless P2, end_iter
 275     shift S3, P2
 276     set P3, P2[S3]
 277     print P3
 278     branch iter_loop
 279 end_iter:
 280
 281     delete P0[0]
 282
 283     set P2, .ITERATE_FROM_START_KEYS
 284 iter_loop2:
 285     unless P2, end_iter2
 286     shift S3, P2
 287     set P3, P2[S3]
 288     print P3
 289     branch iter_loop2
 290 end_iter2:
 291     end
 292
 293 CODE
 294 ok 1
 295 ok 3
 296 ok 3
 297 OUT
 298
 299 pasm_output_is( <<'CODE', <<'OUTPUT', "delete with int keys" );
 300     new P0, ['OrderedHash']
 301     set P0["abc"], "Foo"
 302     set P0["def"], 12.6
 303     set P0["ghi"], 5
 304     new P1, ['Key']
 305     set P1, 1
 306     delete P0[P1]
 307     exists I0, P0["abc"]
 308     print I0
 309     exists I0, P0["def"]
 310     print I0
 311     exists I0, P0["ghi"]
 312     print I0
 313     print "\n"
 314     end
 315 CODE
 316 101
 317 OUTPUT
 318
 319 pasm_output_like( <<'CODE', '/[axj]/', "iterate over keys" );
 320     .include "iterator.pasm"
 321     new P0, ['OrderedHash']
 322     new P1, ['String']
 323     set P1, "ok 1\n"
 324     set P0["x"], P1
 325     new P1, ['String']
 326     set P1, "ok 2\n"
 327     set P0["a"], P1
 328     new P1, ['String']
 329     set P1, "ok 3\n"
 330     set P0["j"], P1
 331
 332     iter P2, P0
 333     set P2, .ITERATE_FROM_START_KEYS
 334 iter_loop:
 335     unless P2, end_iter
 336     shift S3, P2
 337     print S3
 338     branch iter_loop
 339 end_iter:
 340     end
 341 CODE
 342
 343 pasm_output_like( <<'CODE', <<'OUT', "iterate over keys, get value" );
 344     .include "iterator.pasm"
 345     new P0, ['OrderedHash']
 346     new P1, ['String']
 347     set P1, "ok 1\n"
 348     set P0["x"], P1
 349     new P1, ['String']
 350     set P1, "ok 2\n"
 351     set P0["a"], P1
 352     new P1, ['String']
 353     set P1, "ok 3\n"
 354     set P0["j"], P1
 355
 356     iter P2, P0
 357     set P2, .ITERATE_FROM_START_KEYS
 358 iter_loop:
 359     unless P2, end_iter
 360     shift S3, P2
 361     set P3, P2[S3]
 362     print P3
 363     branch iter_loop
 364 end_iter:
 365     end
 366 CODE
 367 /ok \d
 368 ok \d
 369 ok \d/
 370 OUT
 371
 372 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash in PIR with PMC value" );
 373
 374 .sub _main
 375     .local pmc hash1
 376     hash1 = new ['OrderedHash']
 377     .local pmc val_in
 378     val_in = new ['String']
 379     val_in = "U"
 380     hash1["X"] = val_in
 381
 382     .local pmc val_out
 383     val_out = hash1['X']
 384     print val_out
 385     print "\n"
 386
 387     end
 388 .end
 389 CODE
 390 U
 391 OUTPUT
 392
 393 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash set_integer_keyed" );
 394
 395 .sub _main
 396     .local pmc hash1
 397     hash1 = new ['OrderedHash']
 398     hash1["X"] = 14
 399
 400     .local pmc val_out
 401     val_out = hash1['X']
 402     print val_out
 403     print "\n"
 404
 405     end
 406 .end
 407 CODE
 408 14
 409 OUTPUT
 410
 411 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash set_string_keyed" );
 412
 413 .sub _main
 414     .local pmc hash1
 415     hash1 = new ['OrderedHash']
 416     .local string val1
 417     val1 = 'U'
 418     set hash1["X"], val1
 419
 420     .local pmc val_out
 421     val_out = hash1['X']
 422     print val_out
 423     print "\n"
 424
 425     end
 426 .end
 427 CODE
 428 U
 429 OUTPUT
 430
 431 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash set_string_keyed" );
 432
 433 .sub _main
 434     .local pmc hash1
 435     hash1 = new ['OrderedHash']
 436     hash1["X"] = '14'
 437
 438     .local pmc val_out
 439     val_out = hash1['X']
 440     print val_out
 441     print "\n"
 442
 443     end
 444 .end
 445 CODE
 446 14
 447 OUTPUT
 448
 449 # actually Parrot_OrderedHash_set_string_keyed is used, why ?
 450 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash set_string_keyed_str" );
 451
 452 .sub _main
 453     .local pmc hash1
 454     hash1 = new ['OrderedHash']
 455     .local string key1
 456     key1 = 'X'
 457
 458     hash1[key1] = '15'
 459
 460     .local pmc val_out
 461     val_out = hash1[key1]
 462     print val_out
 463     print "\n"
 464
 465     end
 466 .end
 467 CODE
 468 15
 469 OUTPUT
 470
 471 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash set_number_keyed" );
 472
 473 .sub _main
 474     .local pmc hash1
 475     hash1 = new ['OrderedHash']
 476     .local string key1
 477     key1 = 'X'
 478
 479     hash1[key1] = -16.16
 480
 481     .local pmc val_out
 482     val_out = hash1[key1]
 483     print val_out
 484     print "\n"
 485
 486     end
 487 .end
 488 CODE
 489 -16.16
 490 OUTPUT
 491
 492 pir_output_is( << 'CODE', << 'OUTPUT', "OrderedHash get_integer" );
 493
 494 .sub _main
 495     .local pmc hash1
 496     hash1 = new ['OrderedHash']
 497
 498     .local int hash_size
 499     hash_size = hash1
 500     print hash_size
 501     print "\n"
 502
 503     hash1['X'] = 'U'
 504     hash_size = hash1
 505     print hash_size
 506     print "\n"
 507
 508     hash1['Y'] = 'V'
 509     hash_size = hash1
 510     print hash_size
 511     print "\n"
 512
 513     hash1['size'] = hash_size
 514     hash_size = hash1
 515     print hash_size
 516     print "\n"
 517
 518     end
 519 .end
 520 CODE
 521 0
 522 1
 523 2
 524 3
 525 OUTPUT
 526
 527 pasm_output_is( <<'CODE', <<'OUTPUT', "delete and access remaining" );
 528     new P0, ['OrderedHash']
 529     new P1, ['String']
 530     set P1, "A"
 531     set P0["a"], P1
 532     new P1, ['String']
 533     set P1, "B"
 534     set P0["b"], P1
 535
 536     set P3, P0["b"]
 537     print 'P0["b"]: '
 538     print P3
 539     print "\n"
 540     delete P0["a"]
 541     set P4, P0["b"]
 542     print 'P0["b"]: '
 543     print P4
 544     print "\n"
 545
 546     end
 547 CODE
 548 P0["b"]: B
 549 P0["b"]: B
 550 OUTPUT
 551
 552 pir_output_is( << 'CODE', << 'OUTPUT', "check whether interface is done" );
 553
 554 .sub _main
 555     .local pmc pmc1
 556     pmc1 = new ['OrderedHash']
 557     .local int bool1
 558     does bool1, pmc1, "scalar"
 559     print bool1
 560     print "\n"
 561     does bool1, pmc1, "hash"
 562     print bool1
 563     print "\n"
 564     does bool1, pmc1, "array"
 565     print bool1
 566     print "\n"
 567     does bool1, pmc1, "no_interface"
 568     print bool1
 569     print "\n"
 570     end
 571 .end
 572 CODE
 573 0
 574 1
 575 1
 576 0
 577 OUTPUT
 578
 579 pasm_output_is( <<'CODE', <<'OUTPUT', "get_integer_keyed" );
 580     new P0, ['OrderedHash']
 581     set P0["Foo"], 10
 582     set P0["Bar"], 20
 583     set I0, P0["Bar"]
 584     print I0
 585     print "\n"
 586     set I1, P0["Foo"]
 587     print I1
 588     print "\n"
 589     set I2, P0[0]
 590     print I2
 591     print "\n"
 592     set I3, P0[1]
 593     print I3
 594     print "\n"
 595     end
 596 CODE
 597 20
 598 10
 599 10
 600 20
 601 OUTPUT
 602
 603 pasm_output_is( <<'CODE', <<'OUTPUT', "get_number_keyed" );
 604      new P0, ['OrderedHash']
 605      set N0, 12.3
 606      set N1, 45.1
 607      set P0["Foo"], N0
 608      set P0["ooF"], N1
 609      set N2, P0["ooF"]
 610      eq N1, N2, OK1
 611      print "not "
 612 OK1: print "ok 1\n"
 613      set N3, P0["Foo"]
 614      eq N0, N3, OK2
 615      print "not "
 616 OK2: print "ok 2\n"
 617      set N4, P0[0]
 618      eq N4, N0, OK3
 619      print "not "
 620 OK3: print "ok 3\n"
 621      set N5, P0[1]
 622      eq N5, N1, OK4
 623      print "not "
 624 OK4: print "ok 4\n"
 625      end
 626 CODE
 627 ok 1
 628 ok 2
 629 ok 3
 630 ok 4
 631 OUTPUT
 632
 633 pasm_output_is( <<'CODE', <<'OUTPUT', "freeze/thaw 1" );
 634     new P0, ['OrderedHash']
 635     set P0["a"], "Foo\n"
 636     set P0["b"], "Bar\n"
 637
 638     freeze S0, P0
 639     thaw P1, S0
 640     set P2, P1["a"]
 641     print P2
 642     set P2, P1[0]
 643     print P2
 644     set P2, P1["b"]
 645     print P2
 646     set P2, P1[1]
 647     print P2
 648
 649     end
 650 CODE
 651 Foo
 652 Foo
 653 Bar
 654 Bar
 655 OUTPUT
 656
 657 # Local Variables:
 658 #   mode: cperl
 659 #   cperl-indent-level: 4
 660 #   fill-column: 100
 661 # End:
 662 # vim: expandtab shiftwidth=4: