t/pmc/n_arithmetics.t

   1 #! perl
   2 # Copyright (C) 2001-2005, 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 => 20;
  10
  11 =head1 NAME
  12
  13 t/pmc/n_arithmetics.t - n_* Arithmetic Ops
  14
  15 =head1 SYNOPSIS
  16
  17     % prove t/pmc/n_arithmetics.t
  18
  19 =head1 DESCRIPTION
  20
  21 Tests basic arithmetic ops that construct a new return value on
  22 various combinations of Parrot integer and number types.
  23
  24 =cut
  25
  26 ###
  27 ### Operations on a single INTVAL
  28 ###
  29 pir_output_is( <<'CODE', <<OUTPUT, "take the negative of an Integer" );
  30 .sub _main :main
  31     P0 = new Integer
  32     ## negate zero.
  33     set P0, 0
  34     n_neg P1, P0
  35     print P1
  36     print "\n"
  37     P30 = P1
  38     ## negate a positive number.
  39     set P0, 1234567890
  40     n_neg P1, P0
  41     print P1
  42     print "\n"
  43     ## check that we are not reusing P1.
  44     ne_addr P30, P1, not_broken
  45     print "Broken!\n"
  46 not_broken:
  47     ## negate a negative number.
  48     set P0, -1234567890
  49     P1 = n_neg P0
  50     print P1
  51     print "\n"
  52 .end
  53 CODE
  54 0
  55 -1234567890
  56 1234567890
  57 OUTPUT
  58
  59 pir_output_is( <<'CODE', <<OUTPUT, "take the absolute value of an Integer" );
  60 .sub _main :main
  61     P0 = new Integer
  62     ## find absolute zero (so to speak).
  63     set P0, 0
  64     P1 = n_abs P0
  65     print P1
  66     print "\n"
  67     P30 = P1
  68     ## find the absolute value of a positive Integer.
  69     set P0, 1234567890
  70     n_abs P1, P0
  71     print P1
  72     print "\n"
  73     ## check that we are not reusing P1.
  74     ne_addr P30, P1, not_broken
  75     print "Broken!\n"
  76 not_broken:
  77     ## find the absolute value of a negative number.
  78     set P0, -1234567890
  79     n_abs P1, P0
  80     print P1
  81     print "\n"
  82 .end
  83 CODE
  84 0
  85 1234567890
  86 1234567890
  87 OUTPUT
  88
  89 ###
  90 ### first arg is Integer, second arg is Integer
  91 ###
  92 pir_output_is( <<'CODE', <<OUTPUT, "add Integer to Integer" );
  93 .sub _main :main
  94     P0 = new Integer
  95     set P0, 4000
  96     P1 = new Integer
  97     set P1, -123
  98     P2 = new Integer
  99     set P2, 666
 100     n_add P2, P0, P1
 101     print P2
 102     print "\n"
 103     P30 = P2
 104     P2 = n_add P0, P1
 105     print P2
 106     print "\n"
 107     ## check that we are not reusing P2.
 108     ne_addr P30, P2, not_broken
 109     print "Broken!\n"
 110 not_broken:
 111     ## check adding constants.
 112     P2 = n_add P0, 11
 113     print P2
 114     print "\n"
 115     P0 = n_add P0, 11
 116     print P0
 117     print "\n"
 118 .end
 119 CODE
 120 3877
 121 3877
 122 4011
 123 4011
 124 OUTPUT
 125
 126 pir_output_is( <<'CODE', <<OUTPUT, "subtract Integer from Integer" );
 127 .sub _main :main
 128     P0 = new Integer
 129     set P0, 4000
 130     P1 = new Integer
 131     set P1, -123
 132     P2 = new Integer
 133     set P2, 666
 134     n_sub P2, P0, P1
 135     print P2
 136     print "\n"
 137     P30 = P2
 138     P2 = n_sub P0, P1
 139     print P2
 140     print "\n"
 141     ## check that we are not reusing P2.
 142     ne_addr P30, P2, not_broken
 143     print "Broken!\n"
 144 not_broken:
 145     ## check subtracting constants.
 146     P2 = n_sub P0, 11
 147     print P2
 148     print "\n"
 149     P0 = n_sub P0, 11
 150     print P0
 151     print "\n"
 152 .end
 153 CODE
 154 4123
 155 4123
 156 3989
 157 3989
 158 OUTPUT
 159
 160 pir_output_is( <<'CODE', <<OUTPUT, "multiply Integer with Integer" );
 161 .sub _main :main
 162     P0 = new Integer
 163     set P0, 4000
 164     P1 = new Integer
 165     set P1, -123
 166     P2 = new Integer
 167     set P2, 666
 168     n_mul P2, P0, P1
 169     print P2
 170     print "\n"
 171     P3 = n_mul P0, P1
 172     print P3
 173     print "\n"
 174     ## check multiplying constants.
 175     P2 = n_mul P0, 11
 176     print P2
 177     print "\n"
 178     P0 = n_mul P0, 11
 179     print P0
 180     print "\n"
 181 .end
 182 CODE
 183 -492000
 184 -492000
 185 44000
 186 44000
 187 OUTPUT
 188
 189 pir_output_is( <<'CODE', <<OUTPUT, "divide Integer by Integer" );
 190 .sub _main :main
 191     P0 = new Integer
 192     set P0, 4000
 193     P1 = new Integer
 194     set P1, -123
 195     P2 = new Integer
 196     set P2, 666
 197     n_div P2, P0, P1
 198     print P2
 199     print "\n"
 200     P3 = n_div P0, P1
 201     print P3
 202     print "\n"
 203     ## check dividing by constants.
 204     P2 = n_div P0, 11
 205     print P2
 206     print "\n"
 207     P0 = n_div P0, 11
 208     print P0
 209     print "\n"
 210 .end
 211 CODE
 212 -32.5203
 213 -32.5203
 214 363.636
 215 363.636
 216 OUTPUT
 217
 218 ###
 219 ### Operations on a single NUMVAL
 220 ###
 221 pir_output_is( <<'CODE', <<OUTPUT, "negate a Float" );
 222 .sub _main :main
 223     P0 = new Float
 224     set P0, 0
 225     P1 = n_neg P0
 226     print P1
 227     print "\n"
 228     set P0, -0.0
 229     n_neg P1, P0
 230     print P1
 231     print "\n"
 232     set P0, 123.4567890
 233     P1 = n_neg P0
 234     print P1
 235     print "\n"
 236     set P0, -123.4567890
 237     n_neg P1, P0
 238     print P1
 239     print "\n"
 240 .end
 241 CODE
 242 0
 243 0
 244 -123.457
 245 123.457
 246 OUTPUT
 247
 248 pir_output_is( <<'CODE', <<OUTPUT, "take the absolute value of a Float" );
 249 .sub _main :main
 250     P0 = new Integer
 251     set P0, 0
 252     P1 = n_abs P0
 253     print P1
 254     print "\n"
 255     set P0, -0.0
 256     n_abs P1, P0
 257     print P1
 258     print "\n"
 259     set P0, 123.45678901
 260     n_abs P1, P0
 261     print P1
 262     print "\n"
 263     set P0, -123.45678901
 264     P1 = n_abs P0
 265     print P1
 266     print "\n"
 267 .end
 268 CODE
 269 0
 270 0
 271 123.457
 272 123.457
 273 OUTPUT
 274
 275 ###
 276 ### FLOATVAL and INTVAL tests
 277 ###
 278 pir_output_is( <<'CODE', <<OUTPUT, "add Integer to Float" );
 279 .sub _main :main
 280     P10 = new Integer
 281     set P10, 4000
 282     P0 = new Float
 283     set P0, -123.123
 284     n_add P1, P0, P10
 285     print P1
 286     print "\n"
 287     P30 = P1
 288     P1 = n_add P0, P10
 289     print P1
 290     print "\n"
 291     ## check that we are not reusing P1.
 292     ne_addr P30, P1, not_broken
 293     print "Broken!\n"
 294 not_broken:
 295     P2 = n_add P10, P0
 296     print P2
 297     print "\n"
 298         P1 = n_add P1, P10
 299     print P1
 300     print "\n"
 301 .end
 302 CODE
 303 3876.88
 304 3876.88
 305 3876.88
 306 7876.88
 307 OUTPUT
 308
 309 pir_output_is( <<'CODE', <<OUTPUT, "subtract Integer from Float" );
 310 .sub _main :main
 311     P10 = new Integer
 312     set P10, 4000
 313     P0 = new Float
 314     set P0, -123.123
 315     n_sub P1, P0, P10
 316     print P1
 317     print "\n"
 318     P30 = P1
 319     P1 = n_sub P0, P10
 320     print P1
 321     print "\n"
 322     ## check that we are not reusing P1.
 323     ne_addr P30, P1, not_broken
 324     print "Broken!\n"
 325 not_broken:
 326     P2 = n_sub P10, P0
 327     print P2
 328     print "\n"
 329         P1 = n_sub P1, P10
 330     print P1
 331     print "\n"
 332 .end
 333 CODE
 334 -4123.12
 335 -4123.12
 336 4123.12
 337 -8123.12
 338 OUTPUT
 339
 340 pir_output_is( <<'CODE', <<OUTPUT, "multiply Float with Integer" );
 341 .sub _main :main
 342     P10 = new Integer
 343     set P10, 4000
 344     P0 = new Float
 345     set P0, -123.123
 346     n_mul P1, P0, P10
 347     print P1
 348     print "\n"
 349     P30 = P1
 350     P1 = n_mul P0, P10
 351     print P1
 352     print "\n"
 353     ## check that we are not reusing P1.
 354     ne_addr P30, P1, not_broken
 355     print "Broken!\n"
 356 not_broken:
 357     P1 = n_mul P10, P0
 358     print P1
 359     print "\n"
 360         P1 = n_mul P1, -2
 361     print P1
 362     print "\n"
 363 .end
 364 CODE
 365 -492492
 366 -492492
 367 -492492
 368 984984
 369 OUTPUT
 370
 371 pir_output_is( <<'CODE', <<OUTPUT, "divide Float by Integer" );
 372 .sub _main :main
 373     P10 = new Integer
 374     set P10, 4000
 375     P0 = new Float
 376     set P0, -123.123
 377     n_div P1, P0, P10
 378     print P1
 379     print "\n"
 380     P30 = P1
 381     P1 = n_div P0, P10
 382     print P1
 383     print "\n"
 384     ## check that we are not reusing P1.
 385     ne_addr P30, P1, not_broken
 386     print "Broken!\n"
 387 not_broken:
 388         P1 = n_div P0, 1
 389     print P1
 390     print "\n"
 391         set P0, 100.000
 392         P1 = n_div P0, 100
 393     print P1
 394     print "\n"
 395         P1 = n_div P1, 0.01
 396     print P1
 397     print "\n"
 398 .end
 399 CODE
 400 -0.0307808
 401 -0.0307808
 402 -123.123
 403 1
 404 100
 405 OUTPUT
 406
 407 ###
 408 ### FLOATVAL and FLOATVAL tests
 409 ###
 410 pir_output_is( <<'CODE', <<OUTPUT, "add Float to Float" );
 411 .sub _main :main
 412     P0 = new Float
 413     set P0, 4000.246
 414     P1 = new Float
 415     set P1, -123.123
 416     P2 = new Float
 417     set P2, 6.66
 418     n_add P2, P0, P1
 419     print P2
 420     print "\n"
 421     P30 = P2
 422     P2 = n_add P0, P1
 423     print P2
 424     print "\n"
 425     ## check that we are not reusing P2.
 426     ne_addr P30, P2, not_broken
 427     print "Broken!\n"
 428 not_broken:
 429 .end
 430 CODE
 431 3877.12
 432 3877.12
 433 OUTPUT
 434
 435 ## This tests n_infix_ic_p_p_nc for n_add, n_sub, n_mul, and n_div.  Note that
 436 ## there is no n_infix_ic_p_nc_p op; the PMC argument always comes first.
 437 pir_output_is( <<'CODE', <<OUTPUT, "add/sub/mul/div of Float with constants" );
 438 .sub _main :main
 439     P0 = new Float
 440     set P0, 4000.246
 441     P1 = new Float
 442     set P1, -123.123
 443     P2 = n_add P1, 6.78
 444     print P2
 445     print "\n"
 446     P2 = n_add P0, 6.78
 447     print P2
 448     print "\n"
 449     P2 = n_mul P1, 6.78
 450     print P2
 451     print "\n"
 452     P2 = n_div P0, 6.78
 453     print P2
 454     print "\n"
 455 .end
 456 CODE
 457 -116.343
 458 4007.03
 459 -834.774
 460 590.007
 461 OUTPUT
 462
 463 pir_output_is( <<'CODE', <<OUTPUT, "subtract Float from Float" );
 464 .sub _main :main
 465     P0 = new Float
 466     set P0, 4000.246
 467     P1 = new Float
 468     set P1, -123.123
 469     P2 = new Float
 470     set P2, 6.66
 471     n_sub P2, P0, P1
 472     print P2
 473     print "\n"
 474     P30 = P2
 475     P2 = n_sub P1, P0
 476     print P2
 477     print "\n"
 478     ## check that we are not reusing P2.
 479     ne_addr P30, P2, not_broken
 480     print "Broken!\n"
 481 not_broken:
 482 .end
 483 CODE
 484 4123.37
 485 -4123.37
 486 OUTPUT
 487
 488 pir_output_is( <<'CODE', <<OUTPUT, "multiply Float with Float" );
 489 .sub _main :main
 490     P0 = new Float
 491     set P0, 400.0246
 492     P1 = new Float
 493     set P1, -123.123
 494     P2 = new Float
 495     set P2, 6.66
 496     n_mul P2, P0, P1
 497     print P2
 498     print "\n"
 499     P30 = P2
 500     P2 = n_mul P0, P1
 501     print P2
 502     print "\n"
 503     ## check that we are not reusing P2.
 504     ne_addr P30, P2, not_broken
 505     print "Broken!\n"
 506 not_broken:
 507 .end
 508 CODE
 509 -49252.2
 510 -49252.2
 511 OUTPUT
 512
 513 pir_output_is( <<'CODE', <<OUTPUT, "divide Float by Float" );
 514 .sub _main :main
 515     P0 = new Float
 516     set P0, 4000.246
 517     P1 = new Float
 518     set P1, -123.123
 519     P2 = new Float
 520     set P2, 6.66
 521     n_div P2, P1, P0
 522     print P2
 523     print "\n"
 524     P30 = P2
 525     P2 = n_div P0, P1
 526     print P2
 527     print "\n"
 528     ## check that we are not reusing P2.
 529     ne_addr P30, P2, not_broken
 530     print "Broken!\n"
 531 not_broken:
 532 .end
 533 CODE
 534 -0.0307789
 535 -32.4898
 536 OUTPUT
 537
 538 pir_output_is( <<'CODE', <<'OUTPUT', "verify new PMC" );
 539 .sub main :main
 540     P0 = new Integer
 541     P1 = P0
 542     P0 = n_add P0, 1
 543     print P0
 544     print "\n"
 545     eq_addr P0, P1, nok
 546     print "ok\n"
 547     end
 548 nok:
 549     print "not ok\n"
 550 .end
 551 CODE
 552 1
 553 ok
 554 OUTPUT
 555
 556 pir_output_is( <<'CODE', <<'OUTPUT', ".pragma n_operators" );
 557 .pragma n_operators 1
 558
 559 .sub main :main
 560     P0 = new Integer
 561     P1 = P0
 562     P0 = P0 + 1
 563     print P0
 564     print "\n"
 565     eq_addr P0, P1, nok
 566     print "ok\n"
 567     end
 568 nok:
 569     print "not ok\n"
 570 .end
 571 CODE
 572 1
 573 ok
 574 OUTPUT
 575
 576 pir_output_is( <<'CODE', <<'OUTPUT', ".pragma n_operators - inplace" );
 577 .pragma n_operators 1
 578 .sub main :main
 579     .local pmc p
 580     p = new .Integer
 581     p = 10
 582     p += 4
 583     print p
 584     print "\n"
 585 .end
 586 CODE
 587 14
 588 OUTPUT
 589
 590 # Local Variables:
 591 #   mode: cperl
 592 #   cperl-indent-level: 4
 593 #   fill-column: 100
 594 # End:
 595 # vim: expandtab shiftwidth=4: