t/pmc/resizablebooleanarray.t

   1 #!./parrot
   2 # Copyright (C) 2001-2007, Parrot Foundation.
   3 # $Id$
   4
   5 =head1 NAME
   6
   7 t/pmc/resizablebooleanarray.t - testing the ResizableBooleanArray PMC
   8
   9 =head1 SYNOPSIS
  10
  11     % prove t/pmc/resizablebooleanarray.t
  12
  13 =head1 DESCRIPTION
  14
  15 Tests C<ResizableBooleanArray> PMC. Checks size, sets various elements, including
  16 out-of-bounds test. Checks INT and PMC keys.
  17
  18 =cut
  19
  20 .include 'except_types.pasm'
  21 .include 'fp_equality.pasm'
  22
  23 .sub main :main
  24
  25     .include 'test_more.pir'
  26
  27     plan(68)
  28
  29     setting_array_size()
  30     setting_first_element()
  31     setting_second_element()
  32     setting_negatively_indexed_element()
  33     getting_negatively_indexed_element()
  34     setting_oob_element()
  35     getting_oob_element()
  36     set_via_pmc_keys_access_via_ints()
  37     set_via_int_access_via_key_pmc()
  38     interface_check()
  39     push_integer()
  40     push_and_pop()
  41     pop_bounds_check()
  42     shift_and_unshift()
  43     shift_bounds_check()
  44     aerobics()
  45     direct_access()
  46     sparse_access()
  47     check_for_zeroedness()
  48     pop_into_sparse()
  49     clone_empty()
  50     clone_tests()
  51     alternate_clone_tests()
  52     get_iter_test()
  53
  54 .end
  55
  56
  57 .sub setting_array_size
  58
  59     new $P0, ['ResizableBooleanArray']
  60
  61     is($P0, 0, "new ResizableBooleanArray is empty")
  62
  63     $P0 = 1
  64     is($P0, 1, "int assignment to RBA works")
  65
  66     $P0 = 5
  67     is($P0, 5, "another int assignment to RBA works")
  68
  69     $P0 = 50
  70     is($P0, 50, "yet another int assignment to RBA works")
  71
  72     $P0 = 7
  73     is($P0, 7, "shrinking via int assignment to RBA works")
  74
  75     new $P1, ['ExceptionHandler']
  76     set_addr $P1, caught
  77     $P1.'handle_types'(.EXCEPTION_OUT_OF_BOUNDS)
  78     push_eh $P1
  79     $P0 = -1
  80     ok(0, "no exception caught for setting negative size")
  81     .return()
  82 caught:
  83     ok(1, "caught exception on setting negative size")
  84 .end
  85
  86
  87 .sub setting_first_element
  88
  89     new $P0, ['ResizableBooleanArray']
  90     $P0 = 1
  91
  92     $P0[0] = -7
  93     $I0 = $P0[0]
  94     is($I0, 1, "negative int -> boolean conversion is ok")
  95
  96     $P0[0] = 3.7
  97     $N0 = $P0[0]
  98     is($N0, 1.0, "float -> boolean conversion is ok")
  99
 100     $P0[0] = 17
 101     $I0 = $P0[0]
 102     is($I0, 1, "positive int -> boolean conversion is ok")
 103
 104 .end
 105
 106 .sub setting_second_element
 107
 108     new $P0, ['ResizableBooleanArray']
 109     $P0 = 2
 110
 111     $P0[1] = -7
 112     $I0 = $P0[1]
 113     is($I0, 1, "negative int -> boolean conversion is ok")
 114
 115     $P0[1] = 3.7
 116     $N0 = $P0[1]
 117     is($N0, 1.0, "float -> boolean conversion is ok")
 118
 119     $P0[1] = 17
 120     $I0 = $P0[1]
 121     is($I0, 1, "positive int -> boolean conversion is ok")
 122
 123 .end
 124
 125
 126 .sub setting_negatively_indexed_element
 127     new $P0, ['ResizableBooleanArray']
 128     new $P1, ['ExceptionHandler']
 129
 130     set_addr $P1, caught
 131     $P1.'handle_types'(.EXCEPTION_OUT_OF_BOUNDS)
 132     push_eh $P1
 133
 134     set $P0[-1], 1
 135     pop_eh
 136
 137     ok(0, "no exception caught for negative index access")
 138     goto end
 139
 140 caught:
 141     ok(1, "caught exception on negative index access")
 142 end:
 143 .end
 144
 145
 146 .sub getting_negatively_indexed_element
 147     new $P0, ['ResizableBooleanArray']
 148     set $P0, 1
 149
 150     set $I0, $P0[-1]
 151     is($I0, 0, "negative index retrieval is 0")
 152
 153     new $P1, ['ExceptionHandler']
 154     set_addr $P1, caught
 155     $P1.'handle_types'(.EXCEPTION_OUT_OF_BOUNDS)
 156     push_eh $P1
 157     set $I0, $P0[-2]
 158     ok(0, "no exception caught for negative index out of range access")
 159     .return()
 160 caught:
 161     pop_eh
 162     ok(1, "caught exception on negative index out of range access")
 163 .end
 164
 165
 166 .sub setting_oob_element
 167     new $P0, ['ResizableBooleanArray']
 168
 169     set $P0[1], -7
 170     set $I0, $P0[1]
 171     is($I0, 1, "negative oob assignment is fine")
 172
 173     $P0[2] = 3.7
 174     $N0 = $P0[2]
 175     is($N0, 1.0, "float -> boolean conversion w/ oob assignment is ok")
 176
 177     $P0[3] = 17
 178     $I0 = $P0[3]
 179     is($I0, 1, "positive int -> boolean conversion w/ oob assignment is ok")
 180
 181 .end
 182
 183
 184 .sub getting_oob_element
 185     new $P0, ['ResizableBooleanArray']
 186     set $P0, 1
 187
 188     set $I0, $P0[1]
 189     ok(1, "setting/getting an oob element worked")
 190 .end
 191
 192
 193 .sub set_via_pmc_keys_access_via_ints
 194      new $P0, ['ResizableBooleanArray']
 195      new $P1, ['Key']
 196
 197      set $P1, 0
 198      set $P0[$P1], 25
 199
 200      set $P1, 1
 201      set $P0[$P1], 2.5
 202
 203      set $P1, 2
 204      set $P0[$P1], "17"
 205
 206      set $I0, $P0[0]
 207      is($I0, 1, "key set, int get worked")
 208
 209      set $N0, $P0[1]
 210      is($N0, 1.0, "key set, num get worked")
 211
 212      set $S0, $P0[2]
 213      is($S0, "1", "key set, string get worked")
 214 .end
 215
 216 .sub set_via_int_access_via_key_pmc
 217      new $P0, ['ResizableBooleanArray']
 218      set $P0, 1
 219
 220      set $P0[25], 125
 221      set $P0[128], 10.2
 222      set $P0[513], "17"
 223      new $P1, ['Integer']
 224      set $P1, 123456
 225      set $P0[1023], $P1
 226
 227      new $P2, ['Key']
 228      set $P2, 25
 229      set $I0, $P0[$P2]
 230      is($I0, 1, "int set, key get worked")
 231
 232      set $P2, 128
 233      set $N0, $P0[$P2]
 234      is($N0, 1.0, "int set, key get worked")
 235
 236      set $P2, 513
 237      set $S0, $P0[$P2]
 238      is($S0, "1", "int set key get worked")
 239
 240      set $P2, 1023
 241      set $P3, $P0[$P2]
 242      is($P3, 1, "int set, key get worked")
 243 .end
 244
 245 .sub interface_check
 246     .local pmc pmc1
 247     pmc1 = new ['ResizableBooleanArray']
 248     .local int bool1
 249     does bool1, pmc1, "scalar"
 250     is(bool1, 0, "RBA doesn't do 'scalar'")
 251     does bool1, pmc1, "array"
 252     is(bool1, 1, "RBA does 'array'")
 253     does bool1, pmc1, "no_interface"
 254     is(bool1, 0, "RBA doesn't do 'no_interface'")
 255 .end
 256
 257 .sub push_integer
 258     .local pmc pmc1
 259     .local string last
 260     .local int elements
 261
 262     pmc1 = new ['ResizableBooleanArray']
 263     pmc1[9999] = 0
 264     push pmc1, 10001
 265     elements = pmc1
 266     is(elements, 10001, "element count looks good")
 267
 268     last = pmc1[10000]
 269     is(last, 1, "last element has the right value")
 270 .end
 271
 272 .sub push_and_pop
 273     .local int i, i_elem
 274     .local pmc pmc_arr
 275     .local int elements
 276
 277     i = 1
 278     pmc_arr = new ['ResizableBooleanArray']
 279
 280     is(pmc_arr, 0, "new RBA doesn't have any elements")
 281
 282     push pmc_arr, i
 283     is(pmc_arr, 1, "RBA with 1 element says it has 1 element")
 284
 285     push pmc_arr, 0
 286     is(pmc_arr, 2, "RBA with 2 elements says it has 2 elements")
 287
 288     i_elem = pop pmc_arr
 289     is(i_elem, 0, "pop popped the right value")
 290     is(pmc_arr, 1, "RBA has 1 element, as expected")
 291
 292     i_elem = pop pmc_arr
 293     is(i_elem, 1, "pop popped the right value again")
 294     is(pmc_arr, 0, "RBA is now empty, expectedly")
 295
 296     pmc_arr = 62
 297     push pmc_arr, 0
 298     push pmc_arr, 1
 299     push pmc_arr, 0
 300     push pmc_arr, 1
 301     i_elem = pop pmc_arr
 302     i_elem = pop pmc_arr
 303     i_elem = pop pmc_arr
 304     is(i_elem, 1, "pop popped the right thing again")
 305     is(pmc_arr, 63, "RBA has expected size")
 306 .end
 307
 308
 309 .sub pop_bounds_check
 310     $P0 = new ['ResizableBooleanArray']
 311     $P1 = new ['ExceptionHandler']
 312
 313     set_addr $P1, caught
 314     $P1.'handle_types'(.EXCEPTION_OUT_OF_BOUNDS)
 315     push_eh $P1
 316     pop $I0, $P0
 317     pop_eh
 318     ok(0, "failed to catch an oob exception")
 319     goto end
 320 caught:
 321     ok(1, "caught an oob exception")
 322 end:
 323 .end
 324
 325
 326 .sub shift_and_unshift
 327     .local int i, i_elem
 328     .local pmc pmc_arr
 329     .local int elements
 330
 331     i = 1
 332     pmc_arr = new ['ResizableBooleanArray']
 333
 334     # No elements are set
 335     is(pmc_arr, "", "stringification looks ok")
 336
 337     # Set two of the first three elements
 338     pmc_arr[0] = 1
 339     pmc_arr[2] = 1
 340     is(pmc_arr, "101", "stringification w/ 3 elems is good")
 341
 342     # Unshift a "1"  element on
 343     unshift pmc_arr, i
 344     is(pmc_arr, "1101", "still ok")
 345
 346     # Unshift a "0"  element on
 347     unshift pmc_arr, 0
 348     is(pmc_arr, "01101", "still ok")
 349
 350     # Shift an element off
 351     i_elem = shift pmc_arr
 352     is(i_elem, 0, "shift shifted a 0")
 353     is(pmc_arr, "1101", "stringification ok")
 354
 355     # Shift an element off
 356     i_elem = shift pmc_arr
 357     is(i_elem, 1, "shift shifted a 1")
 358     is(pmc_arr, "101", "stringification ok")
 359
 360     # Resize the array
 361     pmc_arr = 25
 362     is(pmc_arr, "1010000000000000000000000", "long stringification is correct")
 363
 364     # Unshift 4 elements on
 365     unshift pmc_arr, 1
 366     unshift pmc_arr, 1
 367     unshift pmc_arr, 0
 368     unshift pmc_arr, 1
 369     is(pmc_arr, "10111010000000000000000000000", "longer stringification is ok")
 370
 371     # Shift 3 elements off
 372     i_elem = shift pmc_arr
 373     i_elem = shift pmc_arr
 374     i_elem = shift pmc_arr
 375     is(i_elem, 1, "shift shifted the right thing")
 376     is(pmc_arr, "11010000000000000000000000", "stringification is still ok")
 377
 378     # Set same size array is currently
 379     pmc_arr = 26
 380     is(pmc_arr, "11010000000000000000000000", "noop size change did nothing")
 381
 382     # Set 101th element
 383     pmc_arr[100] = 1
 384     is(pmc_arr, 101, "setting pmc_arr[100] changed size to 101")
 385
 386     # Shift off 99 elements
 387     .local int counter
 388     counter = 98
 389 shift_loop:
 390     i_elem = shift pmc_arr
 391     dec counter
 392     if counter > 0 goto shift_loop
 393
 394     is(i_elem, 0, "all peachy")
 395     is(pmc_arr, "001", "all's well that ends well")
 396 .end
 397
 398
 399 .sub shift_bounds_check
 400     $P0 = new ['ResizableBooleanArray']
 401     $P1 = new ['ExceptionHandler']
 402
 403     set_addr $P1, caught
 404     $P1.'handle_types'(.EXCEPTION_OUT_OF_BOUNDS)
 405     push_eh $P1
 406
 407     shift $I0, $P0
 408     ok(0, "no OOB exception thrown")
 409     goto end
 410
 411 caught:
 412     ok(1, "OOB exception thrown and caught")
 413
 414 end:
 415 .end
 416
 417 .sub aerobics
 418     .local pmc jmpstack
 419     jmpstack = new 'ResizableIntegerArray'
 420     new $P0, ['ResizableBooleanArray']
 421     set $I10, 10000
 422
 423     set $I1, 0
 424     set $I0, 0
 425   buildup:
 426     ge $I0, $I10, postBuildUp
 427
 428     mod $I4, $I1, 2
 429     push $P0, $I4
 430     add $I1, 1    # Push $P0, mod $I1++, 2
 431     mod $I4, $I1, 2
 432     push $P0, $I4
 433     add $I1, 1    # Push $P0, mod $I1++, 2
 434     mod $I4, $I1, 2
 435     push $P0, $I4
 436     add $I1, 1    # Push $P0, mod $I1++, 2
 437
 438     pop $I2, $P0
 439     mul $I3, $I0, 3
 440     add $I3, 2
 441     mod $I3, 2
 442     ne $I2, $I3, errFirstPop  # fail if pop != mod $I0 * 3 + 2, 2
 443
 444     pop $I2, $P0
 445     mul $I3, $I0, 3
 446     add $I3, 1
 447     mod $I3, 2
 448     ne $I2, $I3, errSecondPop  # fail if pop != mod $I0 * 3 + 1, 2
 449
 450     set $I2, $P0
 451     add $I3, $I0, 1
 452     ne $I2, $I3, errBuildLen   # fail if length != $I0 + 1
 453
 454     add $I0, 1
 455     branch buildup
 456   postBuildUp:
 457
 458     set $I0, 0
 459   checkBuildUpLeft:
 460     ge $I0, $I10, postCheckBuildUpLeft
 461     set $I2, $P0[$I0]
 462     mul $I3, $I0, 3
 463     mod $I3, 2
 464     ne $I2, $I3, errLeftGet
 465     add $I0, 1
 466     branch checkBuildUpLeft
 467   postCheckBuildUpLeft:
 468
 469     mul $I0, $I10, -1
 470   checkBuildUpRight:
 471     ge $I0, 0, postCheckBuildUpRight
 472     set $I2, $P0[$I0]
 473     add $I3, $I0, $I10
 474     mul $I3, 3
 475     mod $I3, 2
 476     ne $I2, $I3, errRightGet
 477     add $I0, 1
 478     branch checkBuildUpRight
 479   postCheckBuildUpRight:
 480
 481     set $I0, $I10
 482   tearDown:
 483     le $I0, 0, postTearDown
 484     pop $I2, $P0
 485     sub $I3, $I0, 1
 486     mod $I3, 2
 487     ne $I2, $I3, errTearDown
 488
 489     sub $I0, 1
 490     branch tearDown
 491   postTearDown:
 492
 493     ok(1, "aerobics completed successfully")
 494     .return()
 495   errFirstPop:
 496     print "FAILED: first pop\n"
 497     local_branch jmpstack, info
 498     .return()
 499   errSecondPop:
 500     print "FAILED: second pop\n"
 501     local_branch jmpstack, info
 502     .return()
 503   errBuildLen:
 504     print "FAILED: buildup length\n"
 505     local_branch jmpstack, info
 506     .return()
 507   errLeftGet:
 508     print "FAILED: left get\n"
 509     local_branch jmpstack, info
 510     .return()
 511   errRightGet:
 512     print "FAILED: right get\n"
 513     local_branch jmpstack, info
 514     .return()
 515   errTearDown:
 516     print "FAILED: tear down cap\n"
 517     local_branch jmpstack, info
 518     .return()
 519   info:
 520     ok(0, "aerobics goof:")
 521     print "#Found: "
 522     print $I2
 523     print "\n#Wanted: "
 524     print $I3
 525     print "\n"
 526     local_return jmpstack
 527 .end
 528
 529
 530 .sub direct_access
 531     new $P0, ['ResizableBooleanArray']
 532     set $I10, 550000
 533     set $I0, 1
 534 lp1:
 535     add $I1, $I0, 5
 536     mod $I2, $I1, 2
 537     set $P0[$I0], $I2
 538     add $I3, $I1, $I0
 539     mod $I2, $I3, 2
 540     push $P0, $I2
 541     shl $I0, $I0, 1
 542     inc $I0
 543     le $I0, $I10, lp1
 544
 545     set $I0, 1
 546 lp2:
 547     add $I1, $I0, 5
 548     mod $I5, $I1, 2
 549     # check at $I0
 550     set $I2, $P0[$I0]
 551     ne $I2, $I5, err
 552     add $I4, $I0, 1
 553     # and pushed value at $I0+1
 554     set $I4, $P0[$I4]
 555     add $I3, $I1, $I0
 556     mod $I5, $I3, 2
 557     ne $I5, $I4, err
 558
 559     shl $I0, $I0, 1
 560     inc $I0
 561     le $I0, $I10, lp2
 562     ok(1, "direct access check passed")
 563     .return()
 564 err:
 565     print "not ok "
 566     print $I0
 567     print " "
 568     print $I1
 569     print " "
 570     print $I2
 571     print " "
 572     print $I3
 573     print " "
 574     print $I4
 575     print " "
 576     print $I5
 577     print " "
 578     print $I6
 579     print " "
 580     print $I7
 581     print "\n"
 582
 583 .end
 584
 585
 586 .sub sparse_access
 587     new $P0, ['ResizableBooleanArray']
 588     set $I10, 110000
 589     set $I0, 1
 590   lp1:
 591     add $I1, $I0, 5
 592     mod $I9, $I1, 2
 593     set $P0[$I0], $I9
 594     add $I3, $I1, $I0
 595     mod $I9, $I3, 2
 596     push $P0, $I9
 597     shl $I0, $I0, 1
 598     inc $I0
 599     le $I0, $I10, lp1
 600
 601     set $I0, 1
 602   lp2:
 603     add $I1, $I0, 5
 604     mod $I9, $I1, 2
 605     # check at $I0
 606     set $I2, $P0[$I0]
 607     ne $I2, $I9, err
 608     add $I4, $I0, 1
 609     # and pushed value at $I0+1
 610     set $I4, $P0[$I4]
 611     add $I3, $I1, $I0
 612     mod $I9, $I3, 2
 613     ne $I9, $I4, err
 614
 615     shl $I0, $I0, 1
 616     inc $I0
 617     le $I0, $I10, lp2
 618     ok(1, "sparse access tests ok")
 619
 620     # now repeat and fill some holes
 621
 622     set $I0, 777
 623   lp3:
 624     add $I1, $I0, 5
 625     mod $I9, $I1, 2
 626     set $P0[$I0], $I9
 627     add $I0, $I0, 666
 628     le $I0, $I10, lp3
 629
 630     set $I0, 777
 631   lp4:
 632     add $I1, $I0, 5
 633     mod $I9, $I1, 2
 634     # check at $I0
 635     set $I2, $P0[$I0]
 636     ne $I2, $I9, err
 637
 638     add $I0, $I0, 666
 639     le $I0, $I10, lp4
 640     ok(1, "sparse access tests still ok")
 641     .return()
 642   err:
 643     print "not ok "
 644     print $I0
 645     print " "
 646     print $I1
 647     print " "
 648     print $I2
 649     print " "
 650     print $I3
 651     print " "
 652     print $I4
 653     print "\n"
 654
 655 .end
 656
 657
 658 .sub check_for_zeroedness
 659     new $P0, ['ResizableBooleanArray']
 660     set $I0, 0
 661 lp1:
 662     push $P0, 0
 663     inc $I0
 664     lt $I0, 100, lp1
 665
 666     set $I2, 10000
 667     set $P0, $I2
 668 lp2:
 669     set $I1, $P0[$I0]
 670     ne $I1, 0, err
 671     inc $I0
 672     lt $I0, $I2, lp2
 673     ok(1, "zeroedness tests passed")
 674     .return()
 675 err:
 676     ok(0, "zeroedness tests failed")
 677     print "#Found non-zero value "
 678     print $I1
 679     print " at "
 680     say $I0
 681 .end
 682
 683
 684 .sub pop_into_sparse
 685     new $P0, ['ResizableBooleanArray']
 686     set $I10, 100
 687     set $I0, 0
 688     # push some values at start
 689 loop1:
 690     mod $I5, $I0, 2
 691     push $P0, $I5
 692     inc $I0
 693     lt $I0, $I10, loop1
 694
 695     # create sparse
 696     set $I0, 100000
 697     set $I1, 1000
 698     mod $I5, $I1, 2
 699     #set $P0[$I0], $I1
 700     set $P0[$I0], $I5
 701     inc $I1
 702 loop2:
 703     # push some values after hole
 704     mod $I5, $I1, 2
 705     push $P0, $I5
 706     inc $I1
 707     le $I1, 1100, loop2
 708     dec $I1
 709
 710     set $I3, $P0
 711 lp3:
 712     set $I4, $P0
 713     ne $I3, $I4, err1
 714     pop $I2, $P0
 715     dec $I3
 716     mod $I5, $I1, 2
 717     ne $I2, $I5, err2
 718     gt $I3, $I0, cont1
 719     lt $I3, $I10, cont1
 720     set $I1, 0
 721
 722     gt $I3, $I10, lp3
 723     set $I1, $I10
 724
 725 cont1:
 726     dec $I1
 727     eq $I1, 0, ok
 728     branch lp3
 729 ok:
 730     ok(1, "pop into sparse tests passed")
 731     .return()
 732     err1:   set $S0, "len"
 733     branch err
 734 err2:
 735     set $S0, "val"
 736 err:
 737     ok(0, "pop into sparse tests failed")
 738     print "#nok "
 739     print $S0
 740     print " "
 741     print $I0
 742     print " "
 743     print $I1
 744     print " "
 745     print $I2
 746     print " "
 747     print $I3
 748     print " "
 749     print $I4
 750     print " "
 751     print $I5
 752 .end
 753
 754 .sub clone_empty
 755     .local pmc rba1, rba2
 756     .local int i
 757     rba1 = new ['ResizableBooleanArray']
 758     rba2 = clone rba1
 759     i = elements rba2
 760     is(i, 0, "clone empty passed")
 761 .end
 762
 763 .sub clone_tests
 764     .local pmc rba1, rba2
 765     .local int i, failed
 766     failed = 0
 767     rba1 = new ['ResizableBooleanArray']
 768
 769     rba1[0]    = 1
 770     rba1[5000] = 1
 771
 772     rba2 = clone rba1
 773
 774     i = rba1[5000]
 775     if i == 1 goto ok_0
 776     failed = 1
 777
 778 ok_0:
 779     i = pop rba1
 780     if i == 1 goto ok_1
 781     failed = 2
 782
 783 ok_1:
 784     i = rba1
 785     if i == 5000 goto ok_2
 786     failed = 3
 787
 788 ok_2:
 789     i = pop rba2
 790     if i == 1 goto ok_3
 791     failed = 4
 792
 793 ok_3:
 794     i = rba2
 795     if i == 5000 goto ok_4
 796     failed = 5
 797
 798 ok_4:
 799     i = rba2[5000] #should be undefined, i.e. 0
 800     if i == 0 goto ok_5
 801     failed = 6
 802
 803 ok_5:
 804     i = pop rba2 #same as previous
 805     if i == 0 goto ok_6
 806     failed = 7
 807     $S0 = rba2
 808     say $S0
 809
 810 ok_6:
 811     is(failed, 0, "all clone tests passed")
 812 .end
 813
 814 .sub alternate_clone_tests
 815     .local pmc rba1, rba2
 816     .local int i, failed
 817     failed = 0
 818     rba1 = new ['ResizableBooleanArray']
 819
 820     rba1[0]    = 1
 821     rba1[4]    = 1
 822     rba1[5004] = 1
 823     i = shift rba1
 824     i = shift rba1
 825     i = shift rba1
 826     i = shift rba1
 827
 828     rba2 = clone rba1
 829
 830     i = rba1[5000]
 831     if i == 1 goto ok_0
 832     failed = 1
 833
 834 ok_0:
 835     i = pop rba1
 836     if i == 1 goto ok_1
 837     failed = 2
 838
 839 ok_1:
 840     i = rba1
 841     if i == 5000 goto ok_2
 842     failed = 3
 843
 844 ok_2:
 845     i = pop rba2
 846     if i == 1 goto ok_3
 847     failed = 4
 848
 849 ok_3:
 850     i = rba2
 851     if i == 5000 goto ok_4
 852     failed = 5
 853
 854 ok_4:
 855     i = rba2[5000] #should be undefined, i.e. 0
 856     if i == 0 goto ok_5
 857     failed = 6
 858
 859 ok_5:
 860     i = pop rba2 #same as previous
 861     if i == 0 goto ok_6
 862     failed = 7
 863
 864 ok_6:
 865     is(failed, 0, "all alternate clone tests passed")
 866 .end
 867
 868 .sub get_iter_test
 869     $P0 = new ['ResizableBooleanArray']
 870     $P0 = 3
 871     $P0[0] = 1
 872     $P0[1] = 0
 873     $P0[2] = 1
 874     $P1 = iter $P0
 875 loop:
 876     unless $P1 goto loop_end
 877     $S2 = shift $P1
 878     $S0 = concat $S0, $S2
 879     goto loop
 880   loop_end:
 881     is($S0, "101", "get_iter works")
 882 .end
 883
 884
 885
 886 # Local Variables:
 887 #   mode: pir
 888 #   fill-column: 100
 889 # End:
 890 # vim: expandtab shiftwidth=4 ft=pir: