Fennel: CalcAssemblerTest Class Reference (original) (raw)
Test instructions that returns a native type.
01326 {
01327 string typestr = getTypeString(type, CalcAssemblerTestCase::MAX_WIDTH);
01328 uint inregs = 4;
01329
01330
01331 ostringstream instostr("");
01332 uint outreg = 0;
01333 CalcTestInfo expectedCalcOut(type);
01334 TProgramCounter pc = 0;
01335 T* pNULL = NULL;
01336 T zero = 0;
01337 T min = std::numeric_limits::min();
01338 T max = std::numeric_limits::max();
01339 T mid = 10;
01340
01341 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01342 const char overflow = "22003";
01343 const char underflow = "22000";
01344
01345 #endif
01346 const char divbyzero = "22012";
01347
01348
01349 addBinaryInstructions(instostr, "ADD", outreg, inregs);
01350 string addstr = string("ADD ") + typestr;
01351 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01352 if (std::numeric_limits::is_signed
01353 && std::numeric_limits::is_integer)
01354 {
01355 expectedCalcOut.add(
01356 addstr, overflow, pc++, LINE);
01357 } else {
01358 expectedCalcOut.add(
01359 addstr, (T) (min + min), pc++, LINE);
01360 }
01361 #else
01362 expectedCalcOut.add(
01363 addstr, (T) (min + min), pc++, LINE);
01364 #endif
01365 expectedCalcOut.add(
01366 addstr, (T) (min + max), pc++, LINE);
01367 expectedCalcOut.add(
01368 addstr, pNULL, pc++, LINE);
01369 expectedCalcOut.add(
01370 addstr, (T) (min + mid), pc++, LINE);
01371
01372 expectedCalcOut.add(
01373 addstr, (T) (max + min), pc++, LINE);
01374 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01375 expectedCalcOut.add(
01376 addstr, overflow, pc++, LINE);
01377 #else
01378 expectedCalcOut.add(
01379 addstr, (T) (max + max), pc++, LINE);
01380 #endif
01381 expectedCalcOut.add(
01382 addstr, pNULL, pc++, LINE);
01383 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01384 if (std::numeric_limits::is_integer) {
01385 expectedCalcOut.add(
01386 addstr, overflow, pc++, LINE);
01387 } else {
01388 expectedCalcOut.add(
01389 addstr, (T) (max + mid), pc++, LINE);
01390 }
01391 #else
01392 expectedCalcOut.add(
01393 addstr, (T) (max + mid), pc++, LINE);
01394 #endif
01395
01396
01397 expectedCalcOut.add(
01398 addstr, pNULL, pc++, LINE);
01399 expectedCalcOut.add(
01400 addstr, pNULL, pc++, LINE);
01401 expectedCalcOut.add(
01402 addstr, pNULL, pc++, LINE);
01403 expectedCalcOut.add(
01404 addstr, pNULL, pc++, LINE);
01405
01406 expectedCalcOut.add(
01407 addstr, (T) (mid + min), pc++, LINE);
01408 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01409 if (std::numeric_limits::is_integer) {
01410 expectedCalcOut.add(
01411 addstr, overflow, pc++, LINE);
01412 } else {
01413 expectedCalcOut.add(
01414 addstr, (T) (mid + max), pc++, LINE);
01415 }
01416 #else
01417 expectedCalcOut.add(
01418 addstr, (T) (mid + max), pc++, LINE);
01419 #endif
01420 expectedCalcOut.add(
01421 addstr, pNULL, pc++, LINE);
01422 expectedCalcOut.add(
01423 addstr, (T) (mid + mid), pc++, LINE);
01424
01425
01426 addBinaryInstructions(instostr, "SUB", outreg, inregs);
01427 string substr = string("SUB ") + typestr;
01428 expectedCalcOut.add(
01429 substr, (T) (min - min), pc++, LINE);
01430 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01431 if (std::numeric_limits::is_integer) {
01432 expectedCalcOut.add(
01433 substr, overflow, pc++, LINE);
01434 } else {
01435 expectedCalcOut.add(
01436 substr, (T) (min - max), pc++, LINE);
01437 }
01438 #else
01439 expectedCalcOut.add(
01440 substr, (T) (min - max), pc++, LINE);
01441 #endif
01442 expectedCalcOut.add(
01443 substr, pNULL, pc++, LINE);
01444 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01445 if (std::numeric_limits::is_integer) {
01446 expectedCalcOut.add(
01447 substr, overflow, pc++, LINE);
01448 } else {
01449 expectedCalcOut.add(
01450 substr, (T) (min - mid), pc++, LINE);
01451 }
01452 #else
01453 expectedCalcOut.add(
01454 substr, (T) (min - mid), pc++, LINE);
01455 #endif
01456
01457 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01458 if (std::numeric_limits::is_signed
01459 && std::numeric_limits::is_integer)
01460 {
01461 expectedCalcOut.add(
01462 substr, overflow, pc++, LINE);
01463 } else {
01464 expectedCalcOut.add(
01465 substr, (T) (max - min), pc++, LINE);
01466 }
01467 #else
01468 expectedCalcOut.add(
01469 substr, (T) (max - min), pc++, LINE);
01470 #endif
01471 expectedCalcOut.add(
01472 substr, (T) (max - max), pc++, LINE);
01473 expectedCalcOut.add(
01474 substr, pNULL, pc++, LINE);
01475 expectedCalcOut.add(
01476 substr, (T) (max - mid), pc++, LINE);
01477
01478 expectedCalcOut.add(
01479 substr, pNULL, pc++, LINE);
01480 expectedCalcOut.add(
01481 substr, pNULL, pc++, LINE);
01482 expectedCalcOut.add(
01483 substr, pNULL, pc++, LINE);
01484 expectedCalcOut.add(
01485 substr, pNULL, pc++, LINE);
01486
01487 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01488 if (std::numeric_limits::is_signed
01489 && std::numeric_limits::is_integer)
01490 {
01491 expectedCalcOut.add(
01492 substr, overflow, pc++, LINE);
01493 } else {
01494 expectedCalcOut.add(
01495 substr, (T) (mid - min), pc++, LINE);
01496 }
01497 #else
01498 expectedCalcOut.add(
01499 substr, (T) (mid - min), pc++, LINE);
01500 #endif
01501 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01502 if (!std::numeric_limits::is_signed) {
01503 expectedCalcOut.add(
01504 substr, overflow, pc++, LINE);
01505 } else {
01506 expectedCalcOut.add(
01507 substr, (T) (mid - max), pc++, LINE);
01508 }
01509 #else
01510 expectedCalcOut.add(
01511 substr, (T) (mid - max), pc++, LINE);
01512 #endif
01513 expectedCalcOut.add(
01514 substr, pNULL, pc++, LINE);
01515 expectedCalcOut.add(
01516 substr, (T) (mid - mid), pc++, LINE);
01517
01518
01519 addBinaryInstructions(instostr, "MUL", outreg, inregs);
01520 string mulstr = string("MUL ") + typestr;
01521 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01522 if (!std::numeric_limits::is_signed) {
01523 expectedCalcOut.add(
01524 mulstr, (T) (min * min), pc++, LINE);
01525 } else if (std::numeric_limits::is_integer) {
01526 expectedCalcOut.add(
01527 mulstr, overflow, pc++, LINE);
01528 } else {
01529 expectedCalcOut.add(
01530 mulstr, underflow, pc++, LINE);
01531 }
01532 #else
01533 expectedCalcOut.add(
01534 mulstr, (T) (min * min), pc++, LINE);
01535 #endif
01536 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01537 if (std::numeric_limits::is_signed
01538 && std::numeric_limits::is_integer)
01539 {
01540 expectedCalcOut.add(
01541 mulstr, overflow, pc++, LINE);
01542 } else {
01543 expectedCalcOut.add(
01544 mulstr, (T) (min * max), pc++, LINE);
01545 }
01546 #else
01547 expectedCalcOut.add(
01548 mulstr, (T) (minmax), pc++, LINE);
01549 #endif
01550 expectedCalcOut.add(
01551 mulstr, pNULL, pc++, LINE);
01552 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01553 if (std::numeric_limits::is_signed
01554 && std::numeric_limits::is_integer)
01555 {
01556 expectedCalcOut.add(
01557 mulstr, overflow, pc++, LINE);
01558 } else {
01559 expectedCalcOut.add(
01560 mulstr, (T) (minmid), pc++, LINE);
01561 }
01562 #else
01563 expectedCalcOut.add(
01564 mulstr, (T) (minmid), pc++, LINE);
01565 #endif
01566
01567 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01568 if (std::numeric_limits::is_signed
01569 && std::numeric_limits::is_integer)
01570 {
01571 expectedCalcOut.add(
01572 mulstr, overflow, pc++, LINE);
01573 } else {
01574 expectedCalcOut.add(
01575 mulstr, (T) (max * min), pc++, LINE);
01576 }
01577 #else
01578 expectedCalcOut.add(
01579 mulstr, (T) (max * min), pc++, LINE);
01580 #endif
01581 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01582 expectedCalcOut.add(
01583 mulstr, overflow, pc++, LINE);
01584 #else
01585 expectedCalcOut.add(
01586 mulstr, (T) (maxmax), pc++, LINE);
01587 #endif
01588 expectedCalcOut.add(
01589 mulstr, pNULL, pc++, LINE);
01590 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01591 expectedCalcOut.add(
01592 mulstr, overflow, pc++, LINE);
01593 #else
01594 expectedCalcOut.add(
01595 mulstr, (T) (maxmid), pc++, LINE);
01596 #endif
01597
01598 expectedCalcOut.add(
01599 mulstr, pNULL, pc++, LINE);
01600 expectedCalcOut.add(
01601 mulstr, pNULL, pc++, LINE);
01602 expectedCalcOut.add(
01603 mulstr, pNULL, pc++, LINE);
01604 expectedCalcOut.add(
01605 mulstr, pNULL, pc++, LINE);
01606
01607 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01608 if (std::numeric_limits::is_signed
01609 && std::numeric_limits::is_integer)
01610 {
01611 expectedCalcOut.add(
01612 mulstr, overflow, pc++, LINE);
01613 } else {
01614 expectedCalcOut.add(
01615 mulstr, (T) (midmin), pc++, LINE);
01616 }
01617 #else
01618 expectedCalcOut.add(
01619 mulstr, (T) (midmin), pc++, LINE);
01620 #endif
01621 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01622 expectedCalcOut.add(
01623 mulstr, overflow, pc++, LINE);
01624 #else
01625 expectedCalcOut.add(
01626 mulstr, (T) (midmax), pc++, LINE);
01627 #endif
01628 expectedCalcOut.add(
01629 mulstr, pNULL, pc++, LINE);
01630 expectedCalcOut.add(
01631 mulstr, (T) (midmid), pc++, LINE);
01632
01633
01634 addBinaryInstructions(instostr, "DIV", outreg, inregs);
01635 string divstr = string("DIV ") + typestr;
01636 if (min != zero) {
01637 expectedCalcOut.add(
01638 divstr, (T) (min / min), pc++, LINE);
01639 } else {
01640 expectedCalcOut.add(
01641 divstr, divbyzero, pc++, LINE);
01642 }
01643 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01644 if (std::numeric_limits::is_integer) {
01645 expectedCalcOut.add(
01646 divstr, (T) (min / max), pc++, LINE);
01647 } else {
01648 expectedCalcOut.add(
01649 divstr, underflow, pc++, LINE);
01650 }
01651 #else
01652 expectedCalcOut.add(
01653 divstr, (T) (min / max), pc++, LINE);
01654 #endif
01655 expectedCalcOut.add(
01656 divstr, pNULL, pc++, LINE);
01657 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01658 if (std::numeric_limits::is_integer) {
01659 expectedCalcOut.add(
01660 divstr, (T) (min / mid), pc++, LINE);
01661 } else {
01662 expectedCalcOut.add(
01663 divstr, underflow, pc++, LINE);
01664 }
01665 #else
01666 expectedCalcOut.add(
01667 divstr, (T) (min / mid), pc++, LINE);
01668 #endif
01669
01670 if (min != zero) {
01671 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01672 if (std::numeric_limits::is_integer) {
01673 expectedCalcOut.add(
01674 divstr, (T) (max / min), pc++, LINE);
01675 } else {
01676 expectedCalcOut.add(
01677 divstr, overflow, pc++, LINE);
01678 }
01679 #else
01680 expectedCalcOut.add(
01681 divstr, (T) (max / min), pc++, LINE);
01682 #endif
01683 } else {
01684 expectedCalcOut.add(
01685 divstr, divbyzero, pc++, LINE);
01686 }
01687 expectedCalcOut.add(
01688 divstr, (T) (max / max), pc++, LINE);
01689 expectedCalcOut.add(
01690 divstr, pNULL, pc++, LINE);
01691 expectedCalcOut.add(
01692 divstr, (T) (max / mid), pc++, LINE);
01693
01694 expectedCalcOut.add(
01695 divstr, pNULL, pc++, LINE);
01696 expectedCalcOut.add(
01697 divstr, pNULL, pc++, LINE);
01698 expectedCalcOut.add(
01699 divstr, pNULL, pc++, LINE);
01700 expectedCalcOut.add(
01701 divstr, pNULL, pc++, LINE);
01702
01703 if (min != zero) {
01704 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01705 if (std::numeric_limits::is_integer) {
01706 expectedCalcOut.add(
01707 divstr, (T) (mid / min), pc++);
01708 } else {
01709 expectedCalcOut.add(
01710 divstr, overflow, pc++, LINE);
01711 }
01712 #else
01713 expectedCalcOut.add(
01714 divstr, (T) (mid / min), pc++);
01715 #endif
01716 } else {
01717 expectedCalcOut.add(
01718 divstr, divbyzero, pc++);
01719 }
01720 expectedCalcOut.add(
01721 divstr, (T) (mid / max), pc++);
01722 expectedCalcOut.add(
01723 divstr, pNULL, pc++);
01724 expectedCalcOut.add(
01725 divstr, (T) (mid / mid), pc++);
01726
01727
01728 addUnaryInstructions(instostr, "NEG", outreg, inregs);
01729 string negstr = string("NEG ") + typestr;
01730 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01731 if (std::numeric_limits::is_signed
01732 && std::numeric_limits::is_integer)
01733 {
01734 expectedCalcOut.add(
01735 negstr, overflow, pc++, LINE);
01736 } else {
01737 expectedCalcOut.add(
01738 negstr, (T) (-min), pc++, LINE);
01739 }
01740 #else
01741 expectedCalcOut.add(
01742 negstr, (T) (-min), pc++, LINE);
01743 #endif
01744 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01745 if (!std::numeric_limits::is_signed) {
01746 expectedCalcOut.add(
01747 negstr, overflow, pc++, LINE);
01748 } else {
01749 expectedCalcOut.add(
01750 negstr, (T) (-max), pc++, LINE);
01751 }
01752 #else
01753 expectedCalcOut.add(
01754 negstr, (T) (-max), pc++, LINE);
01755 #endif
01756 expectedCalcOut.add(
01757 negstr, pNULL, pc++, LINE);
01758 #if defined(USING_NOISY_ARITHMETIC) && USING_NOISY_ARITHMETIC
01759 if (std::numeric_limits::is_signed) {
01760 expectedCalcOut.add(
01761 negstr, (T) (-mid), pc++, LINE);
01762 } else {
01763 expectedCalcOut.add(
01764 negstr, overflow, pc++, LINE);
01765 }
01766 #else
01767 expectedCalcOut.add(
01768 negstr, (T) (-mid), pc++, LINE);
01769 #endif
01770
01771 assert(outreg == static_cast(pc));
01772
01773
01774 string testdesc = "testNativeInstructions: " + typestr;
01775 ostringstream testostr("");
01776
01777 testostr << "I " << createRegisterString(typestr, inregs) << ";" << endl;
01778 testostr << "O " << createRegisterString(typestr, outreg) << ";" << endl;
01779 testostr << "T;" << endl;
01780
01781 testostr << instostr.str();
01782
01783 string teststr = testostr.str();
01784
01785 CalcAssemblerTestCase testCase1(
01786 __LINE__, testdesc.c_str(),
01787 teststr.c_str());
01788 if (testCase1.assemble()) {
01789 testCase1.setInputMin(0);
01790 testCase1.setInputMax(1);
01791 testCase1.setInputNull(2);
01792 testCase1.template setInput(3, mid);
01793 TupleData* outputTuple = testCase1.getExpectedOutputTuple();
01794 assert(outputTuple != NULL);
01795 expectedCalcOut.setTupleData(*outputTuple);
01796 testCase1.test(&expectedCalcOut);
01797 }
01798 }