t/pmc/resizablefloatarray.t

   1 #! perl
   2 # Copyright (C) 2001-2007, The Perl 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 => 19;
  10
  11 =head1 NAME
  12
  13 t/pmc/resizablefloatarray.t - ResizableFloatArray PMC
  14
  15 =head1 SYNOPSIS
  16
  17     % prove t/pmc/resizablefloatarray.t
  18
  19 =head1 DESCRIPTION
  20
  21 Tests C<ResizableFloatArray> PMC. Checks size, sets various elements, including
  22 out-of-bounds test. Checks INT and PMC keys.
  23
  24 =cut
  25
  26 my $fp_equality_macro = <<'ENDOFMACRO';
  27 .macro fp_eq (    J, K, L )
  28     save    N0
  29     save    N1
  30     save    N2
  31
  32     set    N0, .J
  33     set    N1, .K
  34     sub    N2, N1,N0
  35     abs    N2, N2
  36     gt    N2, 0.000001, .$FPEQNOK
  37
  38     restore N2
  39     restore    N1
  40     restore    N0
  41     branch    .L
  42 .label $FPEQNOK:
  43     restore N2
  44     restore    N1
  45     restore    N0
  46 .endm
  47 .macro fp_ne(    J,K,L)
  48     save    N0
  49     save    N1
  50     save    N2
  51
  52     set    N0, .J
  53     set    N1, .K
  54     sub    N2, N1,N0
  55     abs    N2, N2
  56     lt    N2, 0.000001, .$FPNENOK
  57
  58     restore    N2
  59     restore    N1
  60     restore    N0
  61     branch    .L
  62 .label $FPNENOK:
  63     restore    N2
  64     restore    N1
  65     restore    N0
  66 .endm
  67 ENDOFMACRO
  68
  69 pasm_output_is( <<'CODE', <<'OUTPUT', 'creation' );
  70     new P0, 'ResizableFloatArray'
  71     print "ok\n"
  72     end
  73 CODE
  74 ok
  75 OUTPUT
  76
  77 pasm_output_is( <<'CODE', <<'OUTPUT', "Setting array size" );
  78     new P0, 'ResizableFloatArray'
  79
  80     set I0,P0
  81     eq I0,0,OK_1
  82     print "not "
  83 OK_1:    print "ok 1\n"
  84
  85     set P0,1
  86     set I0,P0
  87     eq I0,1,OK_2
  88     print "not "
  89 OK_2:    print "ok 2\n"
  90
  91     set P0,5
  92     set I0,P0
  93     eq I0,5,OK_3
  94     print "not "
  95 OK_3:    print "ok 3\n"
  96
  97     set P0,9
  98     set I0,P0
  99     eq I0,9,OK_4
 100     print "not "
 101 OK_4:    print "ok 4\n"
 102
 103     set P0,7
 104     set I0,P0
 105     eq I0,7,OK_5
 106     print "not "
 107 OK_5:    print "ok 5\n"
 108
 109         end
 110 CODE
 111 ok 1
 112 ok 2
 113 ok 3
 114 ok 4
 115 ok 5
 116 OUTPUT
 117
 118 pasm_error_output_like( <<'CODE', <<'OUTPUT', "Setting negative array size" );
 119     new P0, 'ResizableFloatArray'
 120         set P0, -100
 121         end
 122 CODE
 123 /ResizableFloatArray: Can't resize to negative value!/
 124 OUTPUT
 125
 126 pasm_output_is( <<'CODE', <<'OUTPUT', "Setting first element" );
 127     new P0, 'ResizableFloatArray'
 128     set P0, 1
 129
 130     set P0[0],-7
 131     set I0,P0[0]
 132     eq I0,-7,OK_1
 133     print "not "
 134 OK_1:    print "ok 1\n"
 135
 136     set P0[0],3.7
 137     set N0,P0[0]
 138     eq N0,3.7,OK_2
 139     print "not "
 140 OK_2:    print "ok 2\n"
 141
 142     set P0[0],"17.2"
 143     set S0,P0[0]
 144     eq S0,"17.2",OK_3
 145     print "not "
 146 OK_3:    print "ok 3\n"
 147
 148     end
 149 CODE
 150 ok 1
 151 ok 2
 152 ok 3
 153 OUTPUT
 154
 155 pasm_output_is( <<'CODE', <<'OUTPUT', "Setting second element" );
 156     new P0, 'ResizableFloatArray'
 157
 158     set P0[1], -7
 159     set I0, P0[1]
 160     eq I0,-7,OK_1
 161     print "not "
 162 OK_1:    print "ok 1\n"
 163
 164     set P0[1], 3.7
 165     set N0, P0[1]
 166     eq N0,3.7,OK_2
 167     print "not "
 168 OK_2:    print "ok 2\n"
 169
 170     set P0[1],"17.1"
 171     set S0, P0[1]
 172     eq S0,"17.1",OK_3
 173     print "not "
 174 OK_3:    print "ok 3\n"
 175
 176     end
 177 CODE
 178 ok 1
 179 ok 2
 180 ok 3
 181 OUTPUT
 182
 183 # RT#46823: Rewrite these properly when we have exceptions
 184
 185 pasm_output_is( <<'CODE', <<'OUTPUT', "Setting out-of-bounds elements" );
 186     new P0, 'ResizableFloatArray'
 187     set P0, 1
 188
 189     set P0[1], -7
 190     print "ok 1\n"
 191
 192     end
 193 CODE
 194 ok 1
 195 OUTPUT
 196
 197 pasm_output_is( <<'CODE', <<'OUTPUT', "Getting out-of-bounds elements" );
 198     new P0, 'ResizableFloatArray'
 199     set P0, 1
 200
 201     set I0, P0[1]
 202     print "ok 1\n"
 203     end
 204 CODE
 205 ok 1
 206 OUTPUT
 207
 208 pasm_output_is( <<"CODE", <<'OUTPUT', "Set via PMC keys, access via INTs" );
 209 @{[ $fp_equality_macro ]}
 210      new P0, 'ResizableFloatArray'
 211      new P1, 'Key'
 212
 213      set P1, 0
 214      set P0[P1], 25
 215
 216      set P1, 1
 217      set P0[P1], 2.5
 218
 219      set P1, 2
 220      set P0[P1], "17.32"
 221
 222      set I0, P0[0]
 223      eq I0, 25, OK1
 224      print "not "
 225 OK1: print "ok 1\\n"
 226
 227      set N0, P0[1]
 228      .fp_eq(N0, 2.5, OK2)
 229      print "not "
 230 OK2: print "ok 2\\n"
 231
 232      set S0, P0[2]
 233      eq S0, "17.32", OK3
 234      print "not "
 235 OK3: print "ok 3\\n"
 236
 237      end
 238 CODE
 239 ok 1
 240 ok 2
 241 ok 3
 242 OUTPUT
 243
 244 pasm_output_is( <<"CODE", <<'OUTPUT', "Set via INTs, access via PMC Keys" );
 245 @{[ $fp_equality_macro ]}
 246      new P0, 'ResizableFloatArray'
 247      set P0, 1
 248
 249      set P0[25], 125
 250      set P0[128], 10.2
 251      set P0[513], "17.3"
 252      new P1, 'Integer'
 253      set P1, 123456
 254      set P0[1023], P1
 255
 256      new P2, 'Key'
 257      set P2, 25
 258      set I0, P0[P2]
 259      eq I0, 125, OK1
 260      print "not "
 261 OK1: print "ok 1\\n"
 262
 263      set P2, 128
 264      set N0, P0[P2]
 265      .fp_eq(N0, 10.2, OK2)
 266      print "not "
 267 OK2: print "ok 2\\n"
 268
 269      set P2, 513
 270      set S0, P0[P2]
 271      eq S0, "17.3", OK3
 272      print "not "
 273 OK3: print "ok 3\\n"
 274
 275      set P2, 1023
 276      set P3, P0[P2]
 277      set I1, P3
 278      eq I1, 123456, OK4
 279      print "not "
 280 OK4: print "ok 4\\n"
 281
 282      end
 283 CODE
 284 ok 1
 285 ok 2
 286 ok 3
 287 ok 4
 288 OUTPUT
 289
 290 pasm_output_is( <<"CODE", <<'OUTPUT', 'basic push' );
 291 @{[ $fp_equality_macro ]}
 292      new P0, 'ResizableFloatArray'
 293      push P0, 1.0
 294      push P0, 2.0
 295      push P0, 3.0
 296      set N0, P0[0]
 297      .fp_eq(N0, 1.0, OK1)
 298      print "not "
 299 OK1: print "ok 1\\n"
 300
 301      set N0, P0[1]
 302      .fp_eq(N0, 2.0, OK2)
 303      print "not "
 304 OK2: print "ok 2\\n"
 305
 306      set N0, P0[2]
 307      .fp_eq(N0, 3.0, OK3)
 308      print "not "
 309 OK3: print "ok 3\\n"
 310      end
 311 CODE
 312 ok 1
 313 ok 2
 314 ok 3
 315 OUTPUT
 316
 317 pasm_output_is( <<"CODE", <<'OUTPUT', 'push many values' );
 318 @{[ $fp_equality_macro ]}
 319      new P0, 'ResizableFloatArray'
 320      set I0, 0
 321 L1:  set N0, I0
 322      push P0, N0
 323      inc I0
 324      lt I0, 100000, L1
 325
 326      set N0, P0[99999]
 327      .fp_eq(N0, 99999.0, OK1)
 328      print N0
 329      print "not "
 330 OK1: print "ok 1\\n"
 331      end
 332 CODE
 333 ok 1
 334 OUTPUT
 335
 336 pasm_output_is( <<"CODE", <<'OUTPUT', 'basic pop' );
 337 @{[ $fp_equality_macro ]}
 338      new P0, 'ResizableFloatArray'
 339      set P0[0], 1.0
 340      set P0[1], 2.0
 341      set P0[2], 3.0
 342      pop N0, P0
 343      .fp_eq(N0, 3.0, OK1)
 344      print "not "
 345 OK1: print "ok 1\\n"
 346
 347      pop N0, P0
 348      .fp_eq(N0, 2.0, OK2)
 349      print "not "
 350 OK2: print "ok 2\\n"
 351
 352      pop N0, P0
 353      .fp_eq(N0, 1.0, OK3)
 354      print "not "
 355 OK3: print "ok 3\\n"
 356      end
 357 CODE
 358 ok 1
 359 ok 2
 360 ok 3
 361 OUTPUT
 362
 363 pasm_output_is( <<"CODE", <<'OUTPUT', 'pop many values' );
 364 @{[ $fp_equality_macro ]}
 365      new P0, 'ResizableFloatArray'
 366      set I0, 0
 367 L1:  set N0, I0
 368      set P0[I0], N0
 369      inc I0
 370      lt I0, 100000, L1
 371
 372 L2:  dec I0
 373      set N1, I0
 374      pop N0, P0
 375      .fp_eq(N0, N1, OK)
 376      branch NOT_OK
 377 OK:  gt I0, 0, L2
 378      print "ok\\n"
 379      end
 380
 381 NOT_OK:
 382      print N0
 383      print "\\n"
 384      print N1
 385      print "\\n"
 386      end
 387 CODE
 388 ok
 389 OUTPUT
 390
 391 pasm_output_is( <<"CODE", <<'OUTPUT', 'push/pop' );
 392 @{[ $fp_equality_macro ]}
 393      new P0, 'ResizableFloatArray'
 394      push P0, 1.0
 395      push P0, 2.0
 396      push P0, 3.0
 397      pop N0, P0
 398      .fp_eq(N0, 3.0, OK1)
 399      print "not "
 400 OK1: print "ok 1\\n"
 401      end
 402 CODE
 403 ok 1
 404 OUTPUT
 405
 406 pasm_error_output_like( <<'CODE', <<'OUTPUT', 'pop from empty array' );
 407      new P0, 'ResizableFloatArray'
 408      pop N0, P0
 409      end
 410 CODE
 411 /ResizableFloatArray: Can't pop from an empty array!/
 412 OUTPUT
 413
 414 pir_output_is( << 'CODE', << 'OUTPUT', "check whether interface is done" );
 415
 416 .sub _main
 417     .local pmc pmc1
 418     pmc1 = new 'ResizableFloatArray'
 419     .local int bool1
 420     does bool1, pmc1, "scalar"
 421     print bool1
 422     print "\n"
 423     does bool1, pmc1, "array"
 424     print bool1
 425     print "\n"
 426     does bool1, pmc1, "no_interface"
 427     print bool1
 428     print "\n"
 429     end
 430 .end
 431 CODE
 432 0
 433 1
 434 0
 435 OUTPUT
 436
 437 pir_output_is( << 'CODE', << 'OUTPUT', "push float" );
 438
 439 .sub _main
 440     .local pmc pmc1
 441     pmc1 = new 'ResizableFloatArray'
 442     pmc1[9999] = 10000.10000
 443     push pmc1, 123.123
 444     .local int elements
 445     elements = pmc1
 446     print elements
 447     print "\n"
 448     .local string last
 449     last = pmc1[10000]
 450     print last
 451     print "\n"
 452     end
 453 .end
 454 CODE
 455 10001
 456 123.123
 457 OUTPUT
 458
 459 pir_output_is( << 'CODE', << 'OUTPUT', "shift float" );
 460 .sub test :main
 461     .local pmc ar
 462     ar = new 'ResizableFloatArray'
 463     ar[0] = 10.1
 464     ar[1] = 20.2
 465     $I0 = elements ar
 466     print $I0
 467     print ' '
 468     $N0 = shift ar
 469     print $N0
 470     print ' '
 471     $I0 = elements ar
 472     print $I0
 473     print ' '
 474     $N0 = shift ar
 475     print $N0
 476     print ' '
 477     $I0 = elements ar
 478     print $I0
 479     print "\n"
 480 .end
 481 CODE
 482 2 10.100000 1 20.200000 0
 483 OUTPUT
 484
 485 pir_output_is( << 'CODE', << 'OUTPUT', "unshift float" );
 486 .sub test :main
 487     .local pmc ar
 488     ar = new 'ResizableFloatArray'
 489     unshift ar, 10.1
 490     unshift ar, 20.2
 491     $I0 = elements ar
 492     print $I0
 493     print ' '
 494     $N0 = ar[0]
 495     print $N0
 496     print ' '
 497     $N0 = ar[1]
 498     print $N0
 499     print "\n"
 500 .end
 501 CODE
 502 2 20.200000 10.100000
 503 OUTPUT
 504
 505 # Local Variables:
 506 #   mode: cperl
 507 #   cperl-indent-level: 4
 508 #   fill-column: 100
 509 # End:
 510 # vim: expandtab shiftwidth=4: