home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / test / ieeetest / ieeetest.cpp next >
Encoding:
C/C++ Source or Header  |  1999-08-16  |  15.0 KB  |  731 lines
  1. /*
  2. *******************************************************************************
  3. *                                                                             *
  4. * COPYRIGHT:                                                                  *
  5. *   (C) Copyright International Business Machines Corporation,  1998          *
  6. *   Licensed Material - Program-Property of IBM - All Rights Reserved.        *
  7. *   US Government Users Restricted Rights - Use, duplication, or disclosure   *
  8. *   restricted by GSA ADP Schedule Contract with IBM Corp.                    *
  9. *                                                                             *
  10. *******************************************************************************
  11. *
  12. * File ieeetest.cpp
  13. *
  14. * Modification History:
  15. *
  16. *   Date        Name        Description
  17. *   08/21/98    stephen        Creation.
  18. *******************************************************************************
  19. */
  20.  
  21. #include <iostream.h>        // cout, cerr
  22. #include <float.h>        // DBL_MAX
  23.  
  24. #include "ieeetest.h"
  25. #include "utypes.h"
  26.  
  27. //==============================
  28.  
  29. int
  30. main(int argc, 
  31.      char **argv)
  32. {
  33.   int flags = IEEETest::kNone;
  34.  
  35.   // parse command line switches
  36.   for(int i = 1; i < argc; ++i) {
  37.     if(argv[i][0] == '-') {
  38.       switch(argv[i][1]) {
  39.       case 'v':
  40.     flags += IEEETest::kVerboseMode;
  41.     break;
  42.                 
  43.       case '?':
  44.       case 'h':
  45.       case 'H':
  46.     usage(argv[0]);
  47.     return 0;
  48.     break;
  49.  
  50.       default:
  51.     break;
  52.       }
  53.     }
  54.   }
  55.  
  56.   IEEETest test(flags);    
  57.  
  58.   return test.run();
  59. }
  60.  
  61. //==============================
  62.  
  63. void
  64. usage(const char *execName)
  65. {
  66.   cout << endl;
  67.   cout << "usage: " <<  execName << " [flags]" << endl << endl;
  68.   cout << "Flags:" << endl;
  69.   cout << " -v  Verbose mode" << endl;
  70. }
  71.  
  72. //==============================
  73.  
  74. IEEETest::IEEETest(int flags)
  75.   : mFlags(flags), 
  76.     mTestLevel(0), 
  77.     mNeedLogIndent(TRUE), 
  78.     mNeedErrIndent(TRUE)
  79. {}
  80.  
  81. //==============================
  82.  
  83. IEEETest::~IEEETest()
  84. {}
  85.  
  86. //==============================
  87.  
  88. int
  89. IEEETest::run()
  90. {
  91.   int errCount = 0;
  92.  
  93.   logln();
  94.   log("Starting IEEETest").logln();
  95.   increaseTestLevel();
  96.  
  97.   // add more tests here
  98.   errCount += runTest("NaN behavior", &IEEETest::testNaN);
  99.   errCount += runTest("+Infinity behavior", &IEEETest::testPositiveInfinity);
  100.   errCount += runTest("-Infinity behavior", &IEEETest::testNegativeInfinity);
  101.   errCount += runTest("Zero behavior", &IEEETest::testZero);
  102.     
  103.   decreaseTestLevel();
  104.   if(errCount == 0)
  105.     log("IEEETest Passed");
  106.   else {
  107.     log("IEEETest failed with ").log(errCount)
  108.       .log(errCount == 1 ? " error." : " errors.");
  109.   }
  110.   logln();
  111.  
  112.   if(errCount == 0 && ! (mFlags & kVerboseMode))
  113.     cout << endl << "All tests passed without error." << endl;
  114.  
  115.   return errCount;
  116. }
  117.  
  118. //==============================
  119. int
  120. IEEETest::runTest(const char *testName, 
  121.           int (IEEETest::*testFunc)(void))
  122. {
  123.   logln().log("Running test ").log(testName).logln();
  124.   increaseTestLevel();
  125.   int errCount = (this->*testFunc)();
  126.   decreaseTestLevel();
  127.   log("Test ").log(testName);
  128.   if(errCount == 0)
  129.     log(" passed.");
  130.   else {
  131.     log(" failed with ").log(errCount)
  132.       .log(errCount == 1 ? " error." : " errors.");
  133.   }
  134.  
  135.   logln().logln();
  136.  
  137.   return errCount;
  138. }
  139.  
  140.  
  141. //==============================
  142.  
  143. // NaN is weird- comparisons with NaN _always_ return false, with the
  144. // exception of !=, which _always_ returns true
  145. int
  146. IEEETest::testNaN()
  147. {
  148.   int errCount = 0;
  149.  
  150.   errCount += runTest("isNaN", &IEEETest::testIsNaN);
  151.   errCount += runTest("NaN >", &IEEETest::NaNGT);
  152.   errCount += runTest("NaN <", &IEEETest::NaNLT);
  153.   errCount += runTest("NaN >=", &IEEETest::NaNGTE);
  154.   errCount += runTest("NaN <=", &IEEETest::NaNLTE);
  155.   errCount += runTest("NaN ==", &IEEETest::NaNE);
  156.   errCount += runTest("NaN !=", &IEEETest::NaNNE);
  157.     
  158.   return errCount;
  159. }
  160.  
  161. //==============================
  162.  
  163. int            
  164. IEEETest::testPositiveInfinity()
  165. {
  166.   int errCount = 0;
  167.   double    pinf        = icu_getInfinity();
  168.   double    ninf        = -icu_getInfinity();
  169.   double    ten        = 10.0;
  170.  
  171.   if(icu_isInfinite(pinf) != TRUE) {
  172.     err("FAIL: isInfinite(+Infinity) returned FALSE, should be TRUE.").errln();
  173.     errCount++;
  174.   }
  175.  
  176.   if(icu_isPositiveInfinity(pinf) != TRUE) {
  177.     err("FAIL: isPositiveInfinity(+Infinity) returned FALSE, should be TRUE.").errln();
  178.     errCount++;
  179.   }
  180.  
  181.   if(icu_isNegativeInfinity(pinf) != FALSE) {
  182.     err("FAIL: isNegativeInfinity(+Infinity) returned TRUE, should be FALSE.").errln();
  183.     errCount++;
  184.   }
  185.  
  186.   if(pinf > DBL_MAX != TRUE) {
  187.     err("FAIL: +Infinity > DBL_MAX returned FALSE, should be TRUE.").errln();
  188.     errCount++;
  189.   }
  190.  
  191.   if(pinf > DBL_MIN != TRUE) {
  192.     err("FAIL: +Infinity > DBL_MIN returned FALSE, should be TRUE.").errln();
  193.     errCount++;
  194.   }
  195.  
  196.   if(pinf > ninf != TRUE) {
  197.     err("FAIL: +Infinity > -Infinity returned FALSE, should be TRUE.").errln();
  198.     errCount++;
  199.   }
  200.  
  201.   if(pinf > ten != TRUE) {
  202.     err("FAIL: +Infinity > 10.0 returned FALSE, should be TRUE.").errln();
  203.     errCount++;
  204.   }
  205.  
  206.   return errCount;
  207. }
  208.  
  209. //==============================
  210.  
  211. int            
  212. IEEETest::testNegativeInfinity()
  213. {
  214.   int errCount = 0;
  215.   double    pinf        = icu_getInfinity();
  216.   double    ninf        = -icu_getInfinity();
  217.   double    ten            = 10.0;
  218.  
  219.   if(icu_isInfinite(ninf) != TRUE) {
  220.     err("FAIL: isInfinite(-Infinity) returned FALSE, should be TRUE.").errln();
  221.     errCount++;
  222.   }
  223.  
  224.   if(icu_isNegativeInfinity(ninf) != TRUE) {
  225.     err("FAIL: isNegativeInfinity(-Infinity) returned FALSE, should be TRUE.").errln();
  226.     errCount++;
  227.   }
  228.  
  229.   if(icu_isPositiveInfinity(ninf) != FALSE) {
  230.     err("FAIL: isPositiveInfinity(-Infinity) returned TRUE, should be FALSE.").errln();
  231.     errCount++;
  232.   }
  233.  
  234.   if(ninf < DBL_MAX != TRUE) {
  235.     err("FAIL: -Infinity < DBL_MAX returned FALSE, should be TRUE.").errln();
  236.     errCount++;
  237.   }
  238.  
  239.   if(ninf < DBL_MIN != TRUE) {
  240.     err("FAIL: -Infinity < DBL_MIN returned FALSE, should be TRUE.").errln();
  241.     errCount++;
  242.   }
  243.  
  244.   if(ninf < pinf != TRUE) {
  245.     err("FAIL: -Infinity < +Infinity returned FALSE, should be TRUE.").errln();
  246.     errCount++;
  247.   }
  248.  
  249.   if(ninf < ten != TRUE) {
  250.     err("FAIL: -Infinity < 10.0 returned FALSE, should be TRUE.").errln();
  251.     errCount++;
  252.   }
  253.  
  254.   return errCount;
  255. }
  256.  
  257. //==============================
  258.  
  259. // notes about zero:
  260. // -0.0 == 0.0 == TRUE
  261. // -0.0 <  0.0 == FALSE
  262. // generating -0.0 must be done at runtime.  compiler apparently ignores sign?
  263. int            
  264. IEEETest::testZero()
  265. {
  266.   int errCount = 0;
  267.   double    ten            = 10.0;
  268.   double    pzero        = 0.0;
  269.   double    nzero        = 0.0;
  270.  
  271.   nzero *= -1;
  272.  
  273.   if(pzero == nzero != TRUE) {
  274.     err("FAIL: 0.0 == -0.0 returned FALSE, should be TRUE.").errln();
  275.     errCount++;
  276.   }
  277.  
  278.   if(pzero > nzero != FALSE) {
  279.     err("FAIL: 0.0 > -0.0 returned TRUE, should be FALSE.").errln();
  280.     errCount++;
  281.   }
  282.  
  283.   if(pzero >= nzero != TRUE) {
  284.     err("FAIL: 0.0 >= -0.0 returned FALSE, should be TRUE.").errln();
  285.     errCount++;
  286.   }
  287.  
  288.   if(pzero < nzero != FALSE) {
  289.     err("FAIL: 0.0 < -0.0 returned TRUE, should be FALSE.").errln();
  290.     errCount++;
  291.   }
  292.  
  293.   if(pzero <= nzero != TRUE) {
  294.     err("FAIL: 0.0 <= -0.0 returned FALSE, should be TRUE.").errln();
  295.     errCount++;
  296.   }
  297.  
  298.   if(icu_isInfinite(1/pzero) != TRUE) {
  299.     err("FAIL: isInfinite(1/0.0) returned FALSE, should be TRUE.").errln();
  300.     errCount++;
  301.   }
  302.  
  303.   if(icu_isInfinite(1/nzero) != TRUE) {
  304.     err("FAIL: isInfinite(1/-0.0) returned FALSE, should be TRUE.").errln();
  305.     errCount++;
  306.   }
  307.  
  308.   if(icu_isPositiveInfinity(1/pzero) != TRUE) {
  309.     err("FAIL: isPositiveInfinity(1/0.0) returned FALSE, should be TRUE.").errln();
  310.     errCount++;
  311.   }
  312.  
  313.   if(icu_isNegativeInfinity(1/nzero) != TRUE) {
  314.     err("FAIL: isNegativeInfinity(1/-0.0) returned FALSE, should be TRUE.").errln();
  315.     errCount++;
  316.   }
  317.  
  318.   return errCount;
  319. }
  320.  
  321. //==============================
  322.  
  323. int
  324. IEEETest::testIsNaN()
  325. {
  326.   int numErrors    = 0;
  327.   double    pinf        = icu_getInfinity();
  328.   double    ninf        = -icu_getInfinity();
  329.   double    nan            = icu_getNaN();
  330.   double    ten            = 10.0;
  331.  
  332.   if(icu_isNaN(nan) == FALSE) {
  333.     err("FAIL: isNaN() returned FALSE for NaN.").errln();
  334.     numErrors++;
  335.   }
  336.  
  337.   if(icu_isNaN(pinf) == TRUE) {
  338.     err("FAIL: isNaN() returned TRUE for +Infinity.").errln();
  339.     numErrors++;
  340.   }
  341.  
  342.   if(icu_isNaN(ninf) == TRUE) {
  343.     err("FAIL: isNaN() returned TRUE for -Infinity.").errln();
  344.     numErrors++;
  345.   }
  346.  
  347.   if(icu_isNaN(ten) == TRUE) {
  348.     err("FAIL: isNaN() returned TRUE for 10.0.").errln();
  349.     numErrors++;
  350.   }
  351.  
  352.   return numErrors;
  353. }
  354.  
  355. //==============================
  356.  
  357. int
  358. IEEETest::NaNGT()
  359. {
  360.   double    pinf        = icu_getInfinity();
  361.   double    ninf        = -icu_getInfinity();
  362.   double    nan            = icu_getNaN();
  363.   double    ten            = 10.0;
  364.   int numErrors    = 0;
  365.  
  366.   if(nan > nan != FALSE) {
  367.     err("FAIL: NaN > NaN returned TRUE, should be FALSE").errln();
  368.     numErrors++;
  369.   }
  370.  
  371.   if(nan > pinf != FALSE) {
  372.     err("FAIL: NaN > +Infinity returned TRUE, should be FALSE").errln();
  373.     numErrors++;
  374.   }
  375.  
  376.   if(nan > ninf != FALSE) {
  377.     err("FAIL: NaN > -Infinity returned TRUE, should be FALSE").errln();
  378.     numErrors++;
  379.   }
  380.  
  381.   if(nan > ten != FALSE) {
  382.     err("FAIL: NaN > 10.0 returned TRUE, should be FALSE").errln();
  383.     numErrors++;
  384.   }
  385.  
  386.   return numErrors;
  387. }
  388.  
  389. //==============================
  390.  
  391. int                
  392. IEEETest::NaNLT()
  393. {
  394.   double    pinf        = icu_getInfinity();
  395.   double    ninf        = -icu_getInfinity();
  396.   double    nan            = icu_getNaN();
  397.   double    ten            = 10.0;
  398.   int numErrors    = 0;
  399.  
  400.   if(nan < nan != FALSE) {
  401.     err("FAIL: NaN < NaN returned TRUE, should be FALSE").errln();
  402.     numErrors++;
  403.   }
  404.  
  405.   if(nan < pinf != FALSE) {
  406.     err("FAIL: NaN < +Infinity returned TRUE, should be FALSE").errln();
  407.     numErrors++;
  408.   }
  409.  
  410.   if(nan < ninf != FALSE) {
  411.     err("FAIL: NaN < -Infinity returned TRUE, should be FALSE").errln();
  412.     numErrors++;
  413.   }
  414.  
  415.   if(nan < ten != FALSE) {
  416.     err("FAIL: NaN < 10.0 returned TRUE, should be FALSE").errln();
  417.     numErrors++;
  418.   }
  419.  
  420.   return numErrors;
  421. }
  422.  
  423. //==============================
  424.  
  425. int                
  426. IEEETest::NaNGTE()
  427. {
  428.   double    pinf        = icu_getInfinity();
  429.   double    ninf        = -icu_getInfinity();
  430.   double    nan            = icu_getNaN();
  431.   double    ten            = 10.0;
  432.   int numErrors    = 0;
  433.  
  434.   if(nan >= nan != FALSE) {
  435.     err("FAIL: NaN >= NaN returned TRUE, should be FALSE").errln();
  436.     numErrors++;
  437.   }
  438.  
  439.   if(nan >= pinf != FALSE) {
  440.     err("FAIL: NaN >= +Infinity returned TRUE, should be FALSE").errln();
  441.     numErrors++;
  442.   }
  443.  
  444.   if(nan >= ninf != FALSE) {
  445.     err("FAIL: NaN >= -Infinity returned TRUE, should be FALSE").errln();
  446.     numErrors++;
  447.   }
  448.  
  449.   if(nan >= ten != FALSE) {
  450.     err("FAIL: NaN >= 10.0 returned TRUE, should be FALSE").errln();
  451.     numErrors++;
  452.   }
  453.  
  454.   return numErrors;
  455. }
  456.  
  457. //==============================
  458.  
  459. int                
  460. IEEETest::NaNLTE()
  461. {
  462.   double    pinf        = icu_getInfinity();
  463.   double    ninf        = -icu_getInfinity();
  464.   double    nan            = icu_getNaN();
  465.   double    ten            = 10.0;
  466.   int numErrors    = 0;
  467.  
  468.   if(nan <= nan != FALSE) {
  469.     err("FAIL: NaN <= NaN returned TRUE, should be FALSE").errln();
  470.     numErrors++;
  471.   }
  472.  
  473.   if(nan <= pinf != FALSE) {
  474.     err("FAIL: NaN <= +Infinity returned TRUE, should be FALSE").errln();
  475.     numErrors++;
  476.   }
  477.  
  478.   if(nan <= ninf != FALSE) {
  479.     err("FAIL: NaN <= -Infinity returned TRUE, should be FALSE").errln();
  480.     numErrors++;
  481.   }
  482.  
  483.   if(nan <= ten != FALSE) {
  484.     err("FAIL: NaN <= 10.0 returned TRUE, should be FALSE").errln();
  485.     numErrors++;
  486.   }
  487.  
  488.   return numErrors;
  489. }
  490.  
  491. //==============================
  492.  
  493. int                
  494. IEEETest::NaNE()
  495. {
  496.   double    pinf        = icu_getInfinity();
  497.   double    ninf        = -icu_getInfinity();
  498.   double    nan            = icu_getNaN();
  499.   double    ten            = 10.0;
  500.   int numErrors    = 0;
  501.  
  502.   if(nan == nan != FALSE) {
  503.     err("FAIL: NaN == NaN returned TRUE, should be FALSE").errln();
  504.     numErrors++;
  505.   }
  506.  
  507.   if(nan == pinf != FALSE) {
  508.     err("FAIL: NaN == +Infinity returned TRUE, should be FALSE").errln();
  509.     numErrors++;
  510.   }
  511.  
  512.   if(nan == ninf != FALSE) {
  513.     err("FAIL: NaN == -Infinity returned TRUE, should be FALSE").errln();
  514.     numErrors++;
  515.   }
  516.  
  517.   if(nan == ten != FALSE) {
  518.     err("FAIL: NaN == 10.0 returned TRUE, should be FALSE").errln();
  519.     numErrors++;
  520.   }
  521.  
  522.   return numErrors;
  523. }
  524.  
  525. //==============================
  526.  
  527. int                
  528. IEEETest::NaNNE()
  529. {
  530.   double    pinf        = icu_getInfinity();
  531.   double    ninf        = -icu_getInfinity();
  532.   double    nan            = icu_getNaN();
  533.   double    ten            = 10.0;
  534.   int numErrors    = 0;
  535.  
  536.   if(nan != nan != TRUE) {
  537.     err("FAIL: NaN != NaN returned FALSE, should be TRUE").errln();
  538.     numErrors++;
  539.   }
  540.  
  541.   if(nan != pinf != TRUE) {
  542.     err("FAIL: NaN != +Infinity returned FALSE, should be TRUE").errln();
  543.     numErrors++;
  544.   }
  545.  
  546.   if(nan != ninf != TRUE) {
  547.     err("FAIL: NaN != -Infinity returned FALSE, should be TRUE").errln();
  548.     numErrors++;
  549.   }
  550.  
  551.   if(nan != ten != TRUE) {
  552.     err("FAIL: NaN != 10.0 returned FALSE, should be TRUE").errln();
  553.     numErrors++;
  554.   }
  555.  
  556.   return numErrors;
  557. }
  558.  
  559. //==============================
  560.  
  561. IEEETest& 
  562. IEEETest::log(char c)
  563. {
  564.   if(mFlags & kVerboseMode) {
  565.     if(mNeedLogIndent) {
  566.       for(int j = 0; j < 2 * getTestLevel(); ++j)
  567.     cout << ' ';
  568.       mNeedLogIndent = FALSE;
  569.     }
  570.     cout << c;
  571.   }
  572.   return *this;
  573. }
  574.  
  575. //==============================
  576.  
  577. IEEETest& 
  578. IEEETest::log(const char *s)
  579. {
  580.   if(mFlags & kVerboseMode) {
  581.     if(mNeedLogIndent) {
  582.       for(int j = 0; j < 2 * getTestLevel(); ++j)
  583.     cout << ' ';
  584.       mNeedLogIndent = FALSE;
  585.     }
  586.     cout << s;
  587.   }
  588.   return *this;
  589. }
  590.  
  591. //==============================
  592.  
  593. IEEETest& 
  594. IEEETest::log(int i)
  595. {
  596.   if(mFlags & kVerboseMode) {
  597.     if(mNeedLogIndent) {
  598.       for(int j = 0; j < 2 * getTestLevel(); ++j)
  599.     cout << ' ';
  600.       mNeedLogIndent = FALSE;
  601.     }
  602.     cout << i;
  603.   }
  604.   return *this;
  605. }
  606.  
  607. //==============================
  608.  
  609. IEEETest& 
  610. IEEETest::log(long l)
  611. {
  612.   if(mFlags & kVerboseMode) {
  613.     if(mNeedLogIndent) {
  614.       for(int j = 0; j < 2 * getTestLevel(); ++j)
  615.     cout << ' ';
  616.       mNeedLogIndent = FALSE;
  617.     }
  618.     cout << l;
  619.   }
  620.   return *this;
  621. }
  622.  
  623. //==============================
  624.  
  625. IEEETest& 
  626. IEEETest::log(double d)
  627. {
  628.   if(mFlags & kVerboseMode) {
  629.     if(mNeedLogIndent) {
  630.       for(int j = 0; j < 2 * getTestLevel(); ++j)
  631.     cout << ' ';
  632.       mNeedLogIndent = FALSE;
  633.     }
  634.     cout << d;
  635.   }
  636.   return *this;
  637. }
  638.  
  639. //==============================
  640.  
  641. IEEETest& 
  642. IEEETest::logln()
  643. {
  644.   if(mFlags & kVerboseMode)
  645.     cout << endl;
  646.   mNeedLogIndent = TRUE;
  647.   return *this;
  648. }
  649.  
  650. //==============================
  651.  
  652. IEEETest& 
  653. IEEETest::err(char c)
  654. {
  655.   if(mNeedErrIndent) {
  656.     for(int j = 0; j < 2 * getTestLevel(); ++j)
  657.       cerr << ' ';
  658.     mNeedErrIndent = FALSE;
  659.   }
  660.   cerr << c;
  661.   return *this;
  662. }
  663.  
  664. //==============================
  665.  
  666. IEEETest& 
  667. IEEETest::err(const char *s)
  668. {
  669.   if(mNeedErrIndent) {
  670.     for(int j = 0; j < 2 * getTestLevel(); ++j)
  671.       cerr << ' ';
  672.     mNeedErrIndent = FALSE;
  673.   }
  674.   cerr << s;
  675.   return *this;
  676. }
  677.  
  678. //==============================
  679.  
  680. IEEETest& 
  681. IEEETest::err(int i)
  682. {
  683.   if(mNeedErrIndent) {
  684.     for(int j = 0; j < 2 * getTestLevel(); ++j)
  685.       cerr << ' ';
  686.     mNeedErrIndent = FALSE;
  687.   }
  688.   cerr << i;
  689.   return *this;
  690. }
  691.  
  692. //==============================
  693.  
  694. IEEETest& 
  695. IEEETest::err(long l)
  696. {
  697.   if(mNeedErrIndent) {
  698.     for(int j = 0; j < 2 * getTestLevel(); ++j)
  699.       cerr << ' ';
  700.     mNeedErrIndent = FALSE;
  701.   }
  702.   cerr << l;
  703.   return *this;
  704. }
  705.  
  706. //==============================
  707.  
  708. IEEETest& 
  709. IEEETest::err(double d)
  710. {
  711.   if(mNeedErrIndent) {
  712.     for(int j = 0; j < 2 * getTestLevel(); ++j)
  713.       cerr << ' ';
  714.     mNeedErrIndent = FALSE;
  715.   }
  716.   cerr << d;
  717.   return *this;
  718. }
  719.  
  720. //==============================
  721.  
  722. IEEETest& 
  723. IEEETest::errln()
  724. {
  725.   cerr << endl;
  726.   mNeedErrIndent = TRUE;
  727.   return *this;
  728. }
  729.  
  730. //eof
  731.