ICU-1913 Don't try to test so aggressively on the iSeries.

X-SVN-Rev: 9634

icu4c/source/test/intltest/nmfmtrt.cpp

@@ -108,7 +108,7 @@ NumberFormatRoundTripTest::start()
 void 
 NumberFormatRoundTripTest::test(NumberFormat *fmt)
 {
-#if IEEE_754
+#if IEEE_754 && !defined(OS400)
     test(fmt, uprv_getNaN());
     test(fmt, uprv_getInfinity());
     test(fmt, -uprv_getInfinity());
@@ -129,11 +129,11 @@ NumberFormatRoundTripTest::test(NumberFormat *fmt)
         test(fmt, uprv_floor((randomDouble(10000))));
         test(fmt, randomDouble(1e50));
         test(fmt, randomDouble(1e-50));
-#ifndef OS390
+#if !defined(OS390) && !defined(OS400)
         test(fmt, randomDouble(1e100));
 #elif IEEE_754
-        test(fmt, randomDouble(1e75));    /*OS390*/
-#endif /* OS390 */
+        test(fmt, randomDouble(1e75));    /*OS390 and OS400*/
+#endif /* OS390 and OS400 */
         // {sfb} When formatting with a percent instance, numbers very close to
         // DBL_MAX will fail the round trip.  This is because:
         // 1) Format the double into a string --> INF% (since 100 * double > DBL_MAX)
@@ -146,7 +146,7 @@ NumberFormatRoundTripTest::test(NumberFormat *fmt)
         //if(fmt->getMultipler() == 1)
         if(fmt->getDynamicClassID() == DecimalFormat::getStaticClassID())
         {
-#ifndef OS390
+#if !defined(OS390) && !defined(OS400)
             test(fmt, randomDouble(1e308) / ((DecimalFormat*)fmt)->getMultiplier());
 #elif IEEE_754
             test(fmt, randomDouble(1e75) / ((DecimalFormat*)fmt)->getMultiplier());   
@@ -155,22 +155,22 @@ NumberFormatRoundTripTest::test(NumberFormat *fmt)
 #endif
         }
 
-#if defined XP_MAC || defined __alpha__ || defined OS400 || defined U_OSF
+#if defined XP_MAC || defined __alpha__ || defined U_OSF
 // These machines don't support denormalized doubles,
 // so the low-end range doesn't match Windows
         test(fmt, randomDouble(1e-292));
-#elif defined(OS390)
+#elif defined(OS390) || defined(OS400)
 #   if IEEE_754
-        test(fmt, randomDouble(1e-78));  /*OS390*/
+        test(fmt, randomDouble(1e-78));  /*OS390 and OS400*/
 #   endif
 #else
         test(fmt, randomDouble(1e-323));
-#endif /* OS390 */
-#ifndef OS390
+#endif /* OS390 and OS400*/
+#if !defined(OS390) && !defined(OS400)
         test(fmt, randomDouble(1e-100));
 #elif IEEE_754
-        test(fmt, randomDouble(1e-78));  /*OS390*/
-#endif /* OS390 */
+        test(fmt, randomDouble(1e-78));  /*OS390 and OS400*/
+#endif /* OS390 and OS400*/
     }
 }
 

icu4c/source/test/intltest/tsnmfmt.cpp

@@ -7,7 +7,7 @@
 #include "unicode/utypes.h"
 #include "unicode/decimfmt.h"
 #include "tsnmfmt.h"
-
+#include <float.h>
 
 static const char * formattableTypeName(Formattable::Type t)
 {
@@ -87,6 +87,54 @@ IntlTestNumberFormat::testLocale(/* char* par, */const Locale& locale, const Uni
     testFormat(/* par */);
 }
 
+double IntlTestNumberFormat::randDouble()
+{
+    // Assume 8-bit (or larger) rand values.  Also assume
+    // that the system rand() function is very poor, which it always is.
+    // Call srand(currentTime) in intltest to make it truly random.
+    double d;
+    uint32_t i;
+    char* poke = (char*)&d;
+    do {
+        for (i=0; i < sizeof(double); ++i)
+        {
+            poke[i] = (char)(rand() & 0xFF);
+        }
+    } while (uprv_isNaN(d) || uprv_isInfinite(d)
+        || !((-DBL_MAX < d && d < DBL_MAX) || (d < -DBL_MIN && DBL_MIN < d)));
+
+    return d;
+}
+
+/*
+ * Return a random uint32_t
+ **/
+uint32_t IntlTestNumberFormat::randLong()
+{
+    // Assume 8-bit (or larger) rand values.  Also assume
+    // that the system rand() function is very poor, which it always is.
+    // Call srand(currentTime) in intltest to make it truly random.
+    uint32_t d;
+    uint32_t i;
+    char* poke = (char*)&d;
+    for (i=0; i < sizeof(uint32_t); ++i)
+    {
+        poke[i] = (char)(rand() & 0xFF);
+    }
+    return d;
+}
+
+
+/* Make sure that we don't get something too large and multiply into infinity. */
+double IntlTestNumberFormat::getSafeDouble(double smallerThanMax) {
+    double it;
+    do {
+        it = randDouble();
+    } while (-DBL_MAX/smallerThanMax > it || it > DBL_MAX/smallerThanMax);
+    it *= smallerThanMax/10.0;
+    return it;
+}
+
 void
 IntlTestNumberFormat::testFormat(/* char* par */)
 {
@@ -112,7 +160,7 @@ IntlTestNumberFormat::testFormat(/* char* par */)
     DecimalFormat *s = (DecimalFormat*)fFormat;
     logln((UnicodeString)"  Pattern " + s->toPattern(str));
 
-#ifdef OS390
+#if defined(OS390) || defined(OS400)
     tryIt(-2.02147304840132e-68);
     tryIt(3.88057859588817e-68); // Test rounding when only some digits are shown because exponent is close to -maxfrac
     tryIt(-2.64651110485945e+65); // Overflows to +INF when shown as a percent
@@ -182,19 +230,22 @@ IntlTestNumberFormat::testFormat(/* char* par */)
         tryIt(d);
     }
 
-    double it = randDouble() * 10000;
+    double it = getSafeDouble(100000.0);
+
     tryIt(0.0);
     tryIt(it);
     tryIt((int32_t)0);
-    tryIt((int32_t)uprv_floor(it));
+    tryIt(uprv_floor(it));
+    tryIt((int32_t)randLong());
 
     // try again
-    it = randDouble() * 10;
+    it = getSafeDouble(100.0);
     tryIt(it);
-    tryIt((int32_t)uprv_floor(it));
+    tryIt(uprv_floor(it));
+    tryIt((int32_t)randLong());
 
     // try again with very large numbers
-    it = randDouble() * 10000000000.0;
+    it = getSafeDouble(100000000000.0);
     tryIt(it);
 
     // try again with very large numbers

icu4c/source/test/intltest/tsnmfmt.h

@@ -58,41 +58,20 @@ public:
 
     virtual ~IntlTestNumberFormat() {}
 
+    /*
+     * Return a random double that isn't too large.
+     */
+    static double IntlTestNumberFormat::getSafeDouble(double smallerThanMax);
+
     /*
      * Return a random double
      **/
-    static double randDouble()
-    {
-        // Assume 8-bit (or larger) rand values.  Also assume
-        // that the system rand() function is very poor, which it always is.
-        // Call srand(currentTime) in intltest to make it truly random.
-        double d;
-        uint32_t i;
-        char* poke = (char*)&d;
-        for (i=0; i < sizeof(double); ++i)
-        {
-            poke[i] = (char)(rand() & 0xFF);
-        }
-        return d;
-    }
+    static double randDouble();
 
     /*
      * Return a random uint32_t
      **/
-    static uint32_t randLong()
-    {
-        // Assume 8-bit (or larger) rand values.  Also assume
-        // that the system rand() function is very poor, which it always is.
-        // Call srand(currentTime) in intltest to make it truly random.
-        uint32_t d;
-        uint32_t i;
-        char* poke = (char*)&d;
-        for (i=0; i < sizeof(uint32_t); ++i)
-        {
-            poke[i] = (char)(rand() & 0xFF);
-        }
-        return d;
-    }
+    static uint32_t randLong();
 
     /**
      * Return a random double 0 <= x < 1.0