static void testIEEEremainder() { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); /* double pzero = 0.0;*/ /* double nzero = 0.0; nzero *= -1;*/ /* simple remainder checks*/ remainderTest(7.0, 2.5, -0.5); remainderTest(7.0, -2.5, -0.5); /* this should work remainderTest(43.7, 2.5, 1.2); */ /* infinity and real*/ remainderTest(1.0, pinf, 1.0); remainderTest(1.0, ninf, 1.0); /*test infinity and real*/ remainderTest(nan, 1.0, nan); remainderTest(1.0, nan, nan); /*test infinity and nan*/ remainderTest(ninf, nan, nan); remainderTest(pinf, nan, nan); /* test infinity and zero */ /* remainderTest(pinf, pzero, 1.25); remainderTest(pinf, nzero, 1.25); remainderTest(ninf, pzero, 1.25); remainderTest(ninf, nzero, 1.25); */ }
void PUtilTest::testPositiveInfinity(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double ten = 10.0; if(uprv_isInfinite(pinf) != TRUE) { errln("FAIL: isInfinite(+Infinity) returned FALSE, should be TRUE."); } if(uprv_isPositiveInfinity(pinf) != TRUE) { errln("FAIL: isPositiveInfinity(+Infinity) returned FALSE, should be TRUE."); } if(uprv_isNegativeInfinity(pinf) != FALSE) { errln("FAIL: isNegativeInfinity(+Infinity) returned TRUE, should be FALSE."); } if((pinf > DBL_MAX) != TRUE) { errln("FAIL: +Infinity > DBL_MAX returned FALSE, should be TRUE."); } if((pinf > DBL_MIN) != TRUE) { errln("FAIL: +Infinity > DBL_MIN returned FALSE, should be TRUE."); } if((pinf > ninf) != TRUE) { errln("FAIL: +Infinity > -Infinity returned FALSE, should be TRUE."); } if((pinf > ten) != TRUE) { errln("FAIL: +Infinity > 10.0 returned FALSE, should be TRUE."); } }
void PUtilTest::testNegativeInfinity(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double ten = 10.0; if(uprv_isInfinite(ninf) != TRUE) { errln("FAIL: isInfinite(-Infinity) returned FALSE, should be TRUE."); } if(uprv_isNegativeInfinity(ninf) != TRUE) { errln("FAIL: isNegativeInfinity(-Infinity) returned FALSE, should be TRUE."); } if(uprv_isPositiveInfinity(ninf) != FALSE) { errln("FAIL: isPositiveInfinity(-Infinity) returned TRUE, should be FALSE."); } if((ninf < DBL_MAX) != TRUE) { errln("FAIL: -Infinity < DBL_MAX returned FALSE, should be TRUE."); } if((ninf < DBL_MIN) != TRUE) { errln("FAIL: -Infinity < DBL_MIN returned FALSE, should be TRUE."); } if((ninf < pinf) != TRUE) { errln("FAIL: -Infinity < +Infinity returned FALSE, should be TRUE."); } if((ninf < ten) != TRUE) { errln("FAIL: -Infinity < 10.0 returned FALSE, should be TRUE."); } }
void MessageFormatRegressionTest::Test4094906() { UErrorCode status = U_ZERO_ERROR; UnicodeString pattern("-"); pattern += (UChar) 0x221E; pattern += "<are negative|0<are no or fraction|1#is one|1<is 1+|"; pattern += (UChar) 0x221E; pattern += "<are many."; ChoiceFormat *fmt = new ChoiceFormat(pattern, status); failure(status, "new ChoiceFormat"); UnicodeString pat; if (fmt->toPattern(pat) != pattern) { errln( (UnicodeString) "Formatter Pattern : " + pat); errln( (UnicodeString) "Expected Pattern : " + pattern); } FieldPosition bogus(FieldPosition::DONT_CARE); UnicodeString str; // Will this work for -inf? logln("Format with -INF : " + fmt->format(Formattable(-uprv_getInfinity()), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 0 : " + fmt->format(Formattable((int32_t)0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 0.9 : " + fmt->format(Formattable(0.9), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 1.0 : " + fmt->format(Formattable(1.0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 1.5 : " + fmt->format(Formattable(1.5), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 2 : " + fmt->format(Formattable((int32_t)2), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 2.1 : " + fmt->format(Formattable(2.1), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with NaN : " + fmt->format(Formattable(uprv_getNaN()), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with +INF : " + fmt->format(Formattable(uprv_getInfinity()), str, bogus, status)); failure(status, "fmt->format"); delete fmt; }
void MessageFormatRegressionTest::Test4106661() { UErrorCode status = U_ZERO_ERROR; ChoiceFormat *fmt = new ChoiceFormat( "-1#are negative| 0#are no or fraction | 1#is one |1.0<is 1+ |2#are two |2<are more than 2.", status); failure(status, "new ChoiceFormat"); UnicodeString pat; logln("Formatter Pattern : " + fmt->toPattern(pat)); FieldPosition bogus(FieldPosition::DONT_CARE); UnicodeString str; // Will this work for -inf? logln("Format with -INF : " + fmt->format(Formattable(-uprv_getInfinity()), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with -1.0 : " + fmt->format(Formattable(-1.0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 0 : " + fmt->format(Formattable((int32_t)0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 0.9 : " + fmt->format(Formattable(0.9), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 1.0 : " + fmt->format(Formattable(1.0), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 1.5 : " + fmt->format(Formattable(1.5), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 2 : " + fmt->format(Formattable((int32_t)2), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with 2.1 : " + fmt->format(Formattable(2.1), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with NaN : " + fmt->format(Formattable(uprv_getNaN()), str, bogus, status)); failure(status, "fmt->format"); str.remove(); logln("Format with +INF : " + fmt->format(Formattable(uprv_getInfinity()), str, bogus, status)); failure(status, "fmt->format"); delete fmt; }
void PUtilTest::testIEEEremainder() { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double pzero = 0.0; double nzero = 0.0; nzero *= -1; // simple remainder checks remainderTest(7.0, 2.5, -0.5); remainderTest(7.0, -2.5, -0.5); #ifndef OS390 // ### TODO: // The following tests fails on S/390 with IEEE support in release builds; // debug builds work. // The functioning of ChoiceFormat is not affected by this bug. remainderTest(-7.0, 2.5, 0.5); remainderTest(-7.0, -2.5, 0.5); #endif remainderTest(5.0, 3.0, -1.0); // this should work //remainderTest(43.7, 2.5, 1.25); /* // infinity and real remainderTest(pinf, 1.0, 1.25); remainderTest(1.0, pinf, 1.0); remainderTest(ninf, 1.0, 1.25); remainderTest(1.0, ninf, 1.0); // test infinity and nan remainderTest(ninf, pinf, 1.25); remainderTest(ninf, nan, 1.25); remainderTest(pinf, nan, 1.25); // test infinity and zero remainderTest(pinf, pzero, 1.25); remainderTest(pinf, nzero, 1.25); remainderTest(ninf, pzero, 1.25); remainderTest(ninf, nzero, 1.25); */ }
void PUtilTest::NaNLTE(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double ten = 10.0; if(nan <= nan != FALSE) { logln("WARNING: NaN <= NaN returned TRUE, should be FALSE"); } if(nan <= pinf != FALSE) { logln("WARNING: NaN <= +Infinity returned TRUE, should be FALSE"); } if(nan <= ninf != FALSE) { logln("WARNING: NaN <= -Infinity returned TRUE, should be FALSE"); } if(nan <= ten != FALSE) { logln("WARNING: NaN <= 10.0 returned TRUE, should be FALSE"); } }
void PUtilTest::NaNE(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double ten = 10.0; if((nan == nan) != FALSE) { logln("WARNING: NaN == NaN returned TRUE, should be FALSE"); } if((nan == pinf) != FALSE) { logln("WARNING: NaN == +Infinity returned TRUE, should be FALSE"); } if((nan == ninf) != FALSE) { logln("WARNING: NaN == -Infinity returned TRUE, should be FALSE"); } if((nan == ten) != FALSE) { logln("WARNING: NaN == 10.0 returned TRUE, should be FALSE"); } }
void PUtilTest::NaNGT(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double ten = 10.0; if((nan > nan) != FALSE) { logln("WARNING: NaN > NaN returned TRUE, should be FALSE"); } if((nan > pinf) != FALSE) { logln("WARNING: NaN > +Infinity returned TRUE, should be FALSE"); } if((nan > ninf) != FALSE) { logln("WARNING: NaN > -Infinity returned TRUE, should be FALSE"); } if((nan > ten) != FALSE) { logln("WARNING: NaN > 10.0 returned TRUE, should be FALSE"); } }
void PUtilTest::NaNLT(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double ten = 10.0; if((nan < nan) != FALSE) { logln("WARNING: NaN < NaN returned TRUE, should be FALSE"); } if((nan < pinf) != FALSE) { logln("WARNING: NaN < +Infinity returned TRUE, should be FALSE"); } if((nan < ninf) != FALSE) { logln("WARNING: NaN < -Infinity returned TRUE, should be FALSE"); } if((nan < ten) != FALSE) { logln("WARNING: NaN < 10.0 returned TRUE, should be FALSE"); } }
void PUtilTest::NaNNE(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double ten = 10.0; if((nan != nan) != TRUE) { logln("WARNING: NaN != NaN returned FALSE, should be TRUE"); } if((nan != pinf) != TRUE) { logln("WARNING: NaN != +Infinity returned FALSE, should be TRUE"); } if((nan != ninf) != TRUE) { logln("WARNING: NaN != -Infinity returned FALSE, should be TRUE"); } if((nan != ten) != TRUE) { logln("WARNING: NaN != 10.0 returned FALSE, should be TRUE"); } }
void PUtilTest::testIsNaN(void) { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double ten = 10.0; if(uprv_isNaN(nan) == FALSE) { errln("FAIL: isNaN() returned FALSE for NaN."); } if(uprv_isNaN(pinf) == TRUE) { errln("FAIL: isNaN() returned TRUE for +Infinity."); } if(uprv_isNaN(ninf) == TRUE) { errln("FAIL: isNaN() returned TRUE for -Infinity."); } if(uprv_isNaN(ten) == TRUE) { errln("FAIL: isNaN() returned TRUE for 10.0."); } }
/** * Truncates the given double. * trunc(3.3) = 3.0, trunc (-3.3) = -3.0 * This is different than calling floor() or ceil(): * floor(3.3) = 3, floor(-3.3) = -4 * ceil(3.3) = 4, ceil(-3.3) = -3 */ U_CAPI double U_EXPORT2 uprv_trunc(double d) { #if IEEE_754 int32_t lowBits; /* handle error cases*/ if(uprv_isNaN(d)) return uprv_getNaN(); if(uprv_isInfinite(d)) return uprv_getInfinity(); lowBits = *(uint32_t*) u_bottomNBytesOfDouble(&d, sizeof(uint32_t)); if( (d == 0.0 && (lowBits & SIGN)) || d < 0) return ceil(d); else return floor(d); #else return d >= 0 ? floor(d) : ceil(d); #endif }
static void TestPUtilAPI(void){ double n1=0.0, y1=0.0, expn1, expy1; double value1 = 0.021; char *str=0; UBool isTrue=FALSE; log_verbose("Testing the API uprv_modf()\n"); y1 = uprv_modf(value1, &n1); expn1=0; expy1=0.021; if(y1 != expy1 || n1 != expn1){ log_err("Error in uprv_modf. Expected IntegralValue=%f, Got=%f, \n Expected FractionalValue=%f, Got=%f\n", expn1, n1, expy1, y1); } if(getTestOption(VERBOSITY_OPTION)){ log_verbose("[float] x = %f n = %f y = %f\n", value1, n1, y1); } log_verbose("Testing the API uprv_fmod()\n"); expn1=uprv_fmod(30.50, 15.00); doAssert(expn1, 0.5, "uprv_fmod(30.50, 15.00) failed."); log_verbose("Testing the API uprv_ceil()\n"); expn1=uprv_ceil(value1); doAssert(expn1, 1, "uprv_ceil(0.021) failed."); log_verbose("Testing the API uprv_floor()\n"); expn1=uprv_floor(value1); doAssert(expn1, 0, "uprv_floor(0.021) failed."); log_verbose("Testing the API uprv_fabs()\n"); expn1=uprv_fabs((2.02-1.345)); doAssert(expn1, 0.675, "uprv_fabs(2.02-1.345) failed."); log_verbose("Testing the API uprv_fmax()\n"); doAssert(uprv_fmax(2.4, 1.2), 2.4, "uprv_fmax(2.4, 1.2) failed."); log_verbose("Testing the API uprv_fmax() with x value= NaN\n"); expn1=uprv_fmax(uprv_getNaN(), 1.2); doAssert(expn1, uprv_getNaN(), "uprv_fmax(uprv_getNaN(), 1.2) failed. when one parameter is NaN"); log_verbose("Testing the API uprv_fmin()\n"); doAssert(uprv_fmin(2.4, 1.2), 1.2, "uprv_fmin(2.4, 1.2) failed."); log_verbose("Testing the API uprv_fmin() with x value= NaN\n"); expn1=uprv_fmin(uprv_getNaN(), 1.2); doAssert(expn1, uprv_getNaN(), "uprv_fmin(uprv_getNaN(), 1.2) failed. when one parameter is NaN"); log_verbose("Testing the API uprv_max()\n"); doAssert(uprv_max(4, 2), 4, "uprv_max(4, 2) failed."); log_verbose("Testing the API uprv_min()\n"); doAssert(uprv_min(-4, 2), -4, "uprv_min(-4, 2) failed."); log_verbose("Testing the API uprv_trunc()\n"); doAssert(uprv_trunc(12.3456), 12, "uprv_trunc(12.3456) failed."); doAssert(uprv_trunc(12.234E2), 1223, "uprv_trunc(12.234E2) failed."); doAssert(uprv_trunc(uprv_getNaN()), uprv_getNaN(), "uprv_trunc(uprv_getNaN()) failed. with parameter=NaN"); doAssert(uprv_trunc(uprv_getInfinity()), uprv_getInfinity(), "uprv_trunc(uprv_getInfinity()) failed. with parameter=Infinity"); log_verbose("Testing the API uprv_pow10()\n"); doAssert(uprv_pow10(4), 10000, "uprv_pow10(4) failed."); log_verbose("Testing the API uprv_isNegativeInfinity()\n"); isTrue=uprv_isNegativeInfinity(uprv_getInfinity() * -1); if(isTrue != TRUE){ log_err("ERROR: uprv_isNegativeInfinity failed.\n"); } log_verbose("Testing the API uprv_isPositiveInfinity()\n"); isTrue=uprv_isPositiveInfinity(uprv_getInfinity()); if(isTrue != TRUE){ log_err("ERROR: uprv_isPositiveInfinity failed.\n"); } log_verbose("Testing the API uprv_isInfinite()\n"); isTrue=uprv_isInfinite(uprv_getInfinity()); if(isTrue != TRUE){ log_err("ERROR: uprv_isInfinite failed.\n"); } #if 0 log_verbose("Testing the API uprv_digitsAfterDecimal()....\n"); doAssert(uprv_digitsAfterDecimal(value1), 3, "uprv_digitsAfterDecimal() failed."); doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E-2), 6, "uprv_digitsAfterDecimal(1.2345E-2) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed."); doAssert(uprv_digitsAfterDecimal(-1.2345E-20), 24, "uprv_digitsAfterDecimal(1.2345E-20) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E20), 0, "uprv_digitsAfterDecimal(1.2345E20) failed."); doAssert(uprv_digitsAfterDecimal(-0.021), 3, "uprv_digitsAfterDecimal(-0.021) failed."); doAssert(uprv_digitsAfterDecimal(23.0), 0, "uprv_digitsAfterDecimal(23.0) failed."); doAssert(uprv_digitsAfterDecimal(0.022223333321), 9, "uprv_digitsAfterDecimal(0.022223333321) failed."); #endif log_verbose("Testing the API u_errorName()...\n"); str=(char*)u_errorName((UErrorCode)0); if(strcmp(str, "U_ZERO_ERROR") != 0){ log_err("ERROR: u_getVersion() failed. Expected: U_ZERO_ERROR Got=%s\n", str); } log_verbose("Testing the API u_errorName()...\n"); str=(char*)u_errorName((UErrorCode)-127); if(strcmp(str, "U_USING_DEFAULT_WARNING") != 0){ log_err("ERROR: u_getVersion() failed. Expected: U_USING_DEFAULT_WARNING Got=%s\n", str); } log_verbose("Testing the API u_errorName().. with BOGUS ERRORCODE...\n"); str=(char*)u_errorName((UErrorCode)200); if(strcmp(str, "[BOGUS UErrorCode]") != 0){ log_err("ERROR: u_getVersion() failed. Expected: [BOGUS UErrorCode] Got=%s\n", str); } { const char* dataDirectory; int32_t dataDirectoryLen; UChar *udataDir=0; UChar temp[100]; char *charvalue=0; log_verbose("Testing chars to UChars\n"); /* This cannot really work on a japanese system. u_uastrcpy will have different results than */ /* u_charsToUChars when there is a backslash in the string! */ /*dataDirectory=u_getDataDirectory();*/ dataDirectory="directory1"; /*no backslashes*/ dataDirectoryLen=(int32_t)strlen(dataDirectory); udataDir=(UChar*)malloc(sizeof(UChar) * (dataDirectoryLen + 1)); u_charsToUChars(dataDirectory, udataDir, (dataDirectoryLen + 1)); u_uastrcpy(temp, dataDirectory); if(u_strcmp(temp, udataDir) != 0){ log_err("ERROR: u_charsToUChars failed. Expected %s, Got %s\n", austrdup(temp), austrdup(udataDir)); } log_verbose("Testing UChars to chars\n"); charvalue=(char*)malloc(sizeof(char) * (u_strlen(udataDir) + 1)); u_UCharsToChars(udataDir, charvalue, (u_strlen(udataDir)+1)); if(strcmp(charvalue, dataDirectory) != 0){ log_err("ERROR: u_UCharsToChars failed. Expected %s, Got %s\n", charvalue, dataDirectory); } free(charvalue); free(udataDir); } log_verbose("Testing uprv_timezone()....\n"); { int32_t tzoffset = uprv_timezone(); log_verbose("Value returned from uprv_timezone = %d\n", tzoffset); if (tzoffset != 28800) { log_verbose("***** WARNING: If testing in the PST timezone, t_timezone should return 28800! *****"); } if ((tzoffset % 1800 != 0)) { log_info("Note: t_timezone offset of %ld (for %s : %s) is not a multiple of 30min.", tzoffset, uprv_tzname(0), uprv_tzname(1)); } /*tzoffset=uprv_getUTCtime();*/ } }
void IntlTestDecimalFormatAPI::TestFixedDecimal() { UErrorCode status = U_ZERO_ERROR; LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status); TEST_ASSERT_STATUS(status); FixedDecimal fd = df->getFixedDecimal(44, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(44, fd.source); ASSERT_EQUAL(0, fd.visibleDecimalDigitCount); df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.00##", status), status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(123.456, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); ASSERT_EQUAL(456, fd.decimalDigits); ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(123, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###", status), status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(123.456, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(0, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(123, fd.intValue); ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(123.01, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(1, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(123, fd.intValue); ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(123.06, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(1, fd.visibleDecimalDigitCount); ASSERT_EQUAL(1, fd.decimalDigits); ASSERT_EQUAL(1, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(123, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status); // Significant Digits TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(123, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(123, fd.intValue); ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status); // Significant Digits TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(1.23, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(4, fd.visibleDecimalDigitCount); ASSERT_EQUAL(2300, fd.decimalDigits); ASSERT_EQUAL(23, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(1, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); fd = df->getFixedDecimal(uprv_getInfinity(), status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(TRUE, fd.isNanOrInfinity); fd = df->getFixedDecimal(0.0, status); ASSERT_EQUAL(FALSE, fd.isNanOrInfinity); fd = df->getFixedDecimal(uprv_getNaN(), status); ASSERT_EQUAL(TRUE, fd.isNanOrInfinity); TEST_ASSERT_STATUS(status); // Test Big Decimal input. // 22 digits before and after decimal, will exceed the precision of a double // and force DecimalFormat::getFixedDecimal() to work with a digit list. df.adoptInsteadAndCheckErrorCode( new DecimalFormat("#####################0.00####################", status), status); TEST_ASSERT_STATUS(status); Formattable fable("12.34", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(34, fd.decimalDigits); ASSERT_EQUAL(34, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(12, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); fable.setDecimalNumber("12.345678901234567890123456789", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); ASSERT_EQUAL(345678901234567890LL, fd.decimalDigits); ASSERT_EQUAL(34567890123456789LL, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(12, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); // On field overflow, Integer part is truncated on the left, fraction part on the right. fable.setDecimalNumber("123456789012345678901234567890.123456789012345678901234567890", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); ASSERT_EQUAL(123456789012345678LL, fd.decimalDigits); ASSERT_EQUAL(123456789012345678LL, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(345678901234567890LL, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); // Digits way to the right of the decimal but within the format's precision aren't truncated fable.setDecimalNumber("1.0000000000000000000012", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); ASSERT_EQUAL(12, fd.decimalDigits); ASSERT_EQUAL(12, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(1, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); // Digits beyond the precision of the format are rounded away fable.setDecimalNumber("1.000000000000000000000012", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(1, fd.intValue); ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); // Negative numbers come through fable.setDecimalNumber("-1.0000000000000000000012", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); ASSERT_EQUAL(12, fd.decimalDigits); ASSERT_EQUAL(12, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(1, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(TRUE, fd.isNegative); // MinFractionDigits from format larger than from number. fable.setDecimalNumber("1000000000000000000000.3", status); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(30, fd.decimalDigits); ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(100000000000000000LL, fd.intValue); ASSERT_EQUAL(FALSE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); // Test some int64_t values that are out of the range of a double fable.setInt64(4503599627370496LL); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(4503599627370496LL, fd.intValue); ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); fable.setInt64(4503599627370497LL); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); ASSERT_EQUAL(4503599627370497LL, fd.intValue); ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); fable.setInt64(9223372036854775807LL); TEST_ASSERT_STATUS(status); fd = df->getFixedDecimal(fable, status); TEST_ASSERT_STATUS(status); ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); ASSERT_EQUAL(0, fd.decimalDigits); ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); // note: going through DigitList path to FixedDecimal, which is trimming // int64_t fields to 18 digits. See ticket Ticket #10374 // ASSERT_EQUAL(223372036854775807LL, fd.intValue); if (!(fd.intValue == 223372036854775807LL || fd.intValue == 9223372036854775807LL)) { dataerrln("File %s, Line %d, fd.intValue = %lld", __FILE__, __LINE__, fd.intValue); } ASSERT_EQUAL(TRUE, fd.hasIntegerValue); ASSERT_EQUAL(FALSE, fd.isNegative); }
void MessagePattern::parseDouble(int32_t start, int32_t limit, UBool allowInfinity, UParseError *parseError, UErrorCode &errorCode) { if(U_FAILURE(errorCode)) { return; } U_ASSERT(start<limit); // fake loop for easy exit and single throw statement for(;;) { /*loop doesn't iterate*/ // fast path for small integers and infinity int32_t value=0; int32_t isNegative=0; // not boolean so that we can easily add it to value int32_t index=start; UChar c=msg.charAt(index++); if(c==u_minus) { isNegative=1; if(index==limit) { break; // no number } c=msg.charAt(index++); } else if(c==u_plus) { if(index==limit) { break; // no number } c=msg.charAt(index++); } if(c==0x221e) { // infinity if(allowInfinity && index==limit) { double infinity=uprv_getInfinity(); addArgDoublePart( isNegative!=0 ? -infinity : infinity, start, limit-start, errorCode); return; } else { break; } } // try to parse the number as a small integer but fall back to a double while('0'<=c && c<='9') { value=value*10+(c-'0'); if(value>(Part::MAX_VALUE+isNegative)) { break; // not a small-enough integer } if(index==limit) { addPart(UMSGPAT_PART_TYPE_ARG_INT, start, limit-start, isNegative!=0 ? -value : value, errorCode); return; } c=msg.charAt(index++); } // Let Double.parseDouble() throw a NumberFormatException. char numberChars[128]; int32_t capacity=(int32_t)sizeof(numberChars); int32_t length=limit-start; if(length>=capacity) { break; // number too long } msg.extract(start, length, numberChars, capacity, US_INV); if((int32_t)uprv_strlen(numberChars)<length) { break; // contains non-invariant character that was turned into NUL } char *end; double numericValue=uprv_strtod(numberChars, &end); if(end!=(numberChars+length)) { break; // parsing error } addArgDoublePart(numericValue, start, length, errorCode); return; } setParseError(parseError, start /*, limit*/); // Bad syntax for numeric value. errorCode=U_PATTERN_SYNTAX_ERROR; return; }
static void TestPUtilAPI(void){ double n1=0.0, y1=0.0, expn1, expy1; double value1 = 0.021; UVersionInfo versionArray = {0x01, 0x00, 0x02, 0x02}; char versionString[17]; /* xxx.xxx.xxx.xxx\0 */ char *str=0; UBool isTrue=FALSE; log_verbose("Testing the API uprv_modf()\n"); y1 = uprv_modf(value1, &n1); expn1=0; expy1=0.021; if(y1 != expy1 || n1 != expn1){ log_err("Error in uprv_modf. Expected IntegralValue=%f, Got=%f, \n Expected FractionalValue=%f, Got=%f\n", expn1, n1, expy1, y1); } if(VERBOSITY){ log_verbose("[float] x = %f n = %f y = %f\n", value1, n1, y1); } log_verbose("Testing the API uprv_fmod()\n"); expn1=uprv_fmod(30.50, 15.00); doAssert(expn1, 0.5, "uprv_fmod(30.50, 15.00) failed."); log_verbose("Testing the API uprv_ceil()\n"); expn1=uprv_ceil(value1); doAssert(expn1, 1, "uprv_ceil(0.021) failed."); log_verbose("Testing the API uprv_floor()\n"); expn1=uprv_floor(value1); doAssert(expn1, 0, "uprv_floor(0.021) failed."); log_verbose("Testing the API uprv_fabs()\n"); expn1=uprv_fabs((2.02-1.345)); doAssert(expn1, 0.675, "uprv_fabs(2.02-1.345) failed."); log_verbose("Testing the API uprv_fmax()\n"); doAssert(uprv_fmax(2.4, 1.2), 2.4, "uprv_fmax(2.4, 1.2) failed."); log_verbose("Testing the API uprv_fmax() with x value= NaN\n"); expn1=uprv_fmax(uprv_getNaN(), 1.2); doAssert(expn1, uprv_getNaN(), "uprv_fmax(uprv_getNaN(), 1.2) failed. when one parameter is NaN"); log_verbose("Testing the API uprv_fmin()\n"); doAssert(uprv_fmin(2.4, 1.2), 1.2, "uprv_fmin(2.4, 1.2) failed."); log_verbose("Testing the API uprv_fmin() with x value= NaN\n"); expn1=uprv_fmin(uprv_getNaN(), 1.2); doAssert(expn1, uprv_getNaN(), "uprv_fmin(uprv_getNaN(), 1.2) failed. when one parameter is NaN"); log_verbose("Testing the API uprv_max()\n"); doAssert(uprv_max(4, 2), 4, "uprv_max(4, 2) failed."); log_verbose("Testing the API uprv_min()\n"); doAssert(uprv_min(-4, 2), -4, "uprv_min(-4, 2) failed."); log_verbose("Testing the API uprv_trunc()\n"); doAssert(uprv_trunc(12.3456), 12, "uprv_trunc(12.3456) failed."); doAssert(uprv_trunc(12.234E2), 1223, "uprv_trunc(12.234E2) failed."); doAssert(uprv_trunc(uprv_getNaN()), uprv_getNaN(), "uprv_trunc(uprv_getNaN()) failed. with parameter=NaN"); doAssert(uprv_trunc(uprv_getInfinity()), uprv_getInfinity(), "uprv_trunc(uprv_getInfinity()) failed. with parameter=Infinity"); log_verbose("Testing the API uprv_pow10()\n"); doAssert(uprv_pow10(4), 10000, "uprv_pow10(4) failed."); log_verbose("Testing the API uprv_log10()\n"); doAssert(uprv_log10(3456), 3, "uprv_log10(3456) failed."); #ifdef OS390 doAssert(uprv_log10(1.0e55), 55, "uprv_log10(1.0e55) failed."); #else doAssert(uprv_log10(1.0e300), 300, "uprv_log10(1.0e300) failed."); #endif log_verbose("Testing the API uprv_isNegativeInfinity()\n"); isTrue=uprv_isNegativeInfinity(uprv_getInfinity() * -1); if(isTrue != TRUE){ log_err("ERROR: uprv_isNegativeInfinity failed.\n"); } log_verbose("Testing the API uprv_isPositiveInfinity()\n"); isTrue=uprv_isPositiveInfinity(uprv_getInfinity()); if(isTrue != TRUE){ log_err("ERROR: uprv_isPositiveInfinity failed.\n"); } log_verbose("Testing the API uprv_isInfinite()\n"); isTrue=uprv_isInfinite(uprv_getInfinity()); if(isTrue != TRUE){ log_err("ERROR: uprv_isInfinite failed.\n"); } #if 0 log_verbose("Testing the API uprv_digitsAfterDecimal()....\n"); doAssert(uprv_digitsAfterDecimal(value1), 3, "uprv_digitsAfterDecimal() failed."); doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E-2), 6, "uprv_digitsAfterDecimal(1.2345E-2) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed."); doAssert(uprv_digitsAfterDecimal(-1.2345E-20), 24, "uprv_digitsAfterDecimal(1.2345E-20) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E20), 0, "uprv_digitsAfterDecimal(1.2345E20) failed."); doAssert(uprv_digitsAfterDecimal(-0.021), 3, "uprv_digitsAfterDecimal(-0.021) failed."); doAssert(uprv_digitsAfterDecimal(23.0), 0, "uprv_digitsAfterDecimal(23.0) failed."); doAssert(uprv_digitsAfterDecimal(0.022223333321), 9, "uprv_digitsAfterDecimal(0.022223333321) failed."); #endif log_verbose("Testing the API u_versionToString().....\n"); u_versionToString(versionArray, versionString); if(strcmp(versionString, "1.0.2.2") != 0){ log_err("ERROR: u_versionToString() failed. Expected: 1.0.2.2, Got=%s\n", versionString); } log_verbose("Testing the API u_versionToString().....with versionArray=NULL\n"); u_versionToString(NULL, versionString); if(strcmp(versionString, "") != 0){ log_err("ERROR: u_versionToString() failed. with versionArray=NULL. It should just return\n"); } log_verbose("Testing the API u_versionToString().....with versionArray=NULL\n"); u_versionToString(NULL, versionString); if(strcmp(versionString, "") != 0){ log_err("ERROR: u_versionToString() failed . It should just return\n"); } log_verbose("Testing the API u_versionToString().....with versionString=NULL\n"); u_versionToString(versionArray, NULL); if(strcmp(versionString, "") != 0){ log_err("ERROR: u_versionToString() failed. with versionArray=NULL It should just return\n"); } versionArray[0] = 0x0a; log_verbose("Testing the API u_versionToString().....\n"); u_versionToString(versionArray, versionString); if(strcmp(versionString, "10.0.2.2") != 0){ log_err("ERROR: u_versionToString() failed. Expected: 10.0.2.2, Got=%s\n", versionString); } versionArray[0] = 0xa0; u_versionToString(versionArray, versionString); if(strcmp(versionString, "160.0.2.2") != 0){ log_err("ERROR: u_versionToString() failed. Expected: 160.0.2.2, Got=%s\n", versionString); } versionArray[0] = 0xa0; versionArray[1] = 0xa0; u_versionToString(versionArray, versionString); if(strcmp(versionString, "160.160.2.2") != 0){ log_err("ERROR: u_versionToString() failed. Expected: 160.160.2.2, Got=%s\n", versionString); } versionArray[0] = 0x01; versionArray[1] = 0x0a; u_versionToString(versionArray, versionString); if(strcmp(versionString, "1.10.2.2") != 0){ log_err("ERROR: u_versionToString() failed. Expected: 160.160.2.2, Got=%s\n", versionString); } log_verbose("Testing the API u_versionFromString() ....\n"); u_versionFromString(versionArray, "1.3.5.6"); u_versionToString(versionArray, versionString); if(strcmp(versionString, "1.3.5.6") != 0){ log_err("ERROR: u_getVersion() failed. Expected: 1.3.5.6, Got=%s\n", versionString); } log_verbose("Testing the API u_versionFromString() where versionArray=NULL....\n"); u_versionFromString(NULL, "1.3.5.6"); u_versionToString(versionArray, versionString); if(strcmp(versionString, "1.3.5.6") != 0){ log_err("ERROR: u_getVersion() failed. Expected: 1.3.5.6, Got=%s\n", versionString); } log_verbose("Testing the API u_getVersion().....\n"); u_getVersion(versionArray); u_versionToString(versionArray, versionString); if(strcmp(versionString, U_ICU_VERSION) != 0){ log_err("ERROR: u_getVersion() failed. Got=%s, expected %s\n", versionString, U_ICU_VERSION); } log_verbose("Testing the API u_errorName()...\n"); str=(char*)u_errorName((UErrorCode)0); if(strcmp(str, "U_ZERO_ERROR") != 0){ log_err("ERROR: u_getVersion() failed. Expected: U_ZERO_ERROR Got=%s\n", str); } log_verbose("Testing the API u_errorName()...\n"); str=(char*)u_errorName((UErrorCode)-127); if(strcmp(str, "U_USING_DEFAULT_WARNING") != 0){ log_err("ERROR: u_getVersion() failed. Expected: U_USING_DEFAULT_WARNING Got=%s\n", str); } log_verbose("Testing the API u_errorName().. with BOGUS ERRORCODE...\n"); str=(char*)u_errorName((UErrorCode)200); if(strcmp(str, "[BOGUS UErrorCode]") != 0){ log_err("ERROR: u_getVersion() failed. Expected: [BOGUS UErrorCode] Got=%s\n", str); } { const char* dataDirectory; UChar *udataDir=0; UChar temp[100]; char *charvalue=0; log_verbose("Testing chars to UChars\n"); /* This cannot really work on a japanese system. u_uastrcpy will have different results than */ /* u_charsToUChars when there is a backslash in the string! */ /*dataDirectory=u_getDataDirectory();*/ dataDirectory="directory1"; /*no backslashes*/ udataDir=(UChar*)malloc(sizeof(UChar) * (strlen(dataDirectory) + 1)); u_charsToUChars(dataDirectory, udataDir, (strlen(dataDirectory)+1)); u_uastrcpy(temp, dataDirectory); if(u_strcmp(temp, udataDir) != 0){ log_err("ERROR: u_charsToUChars failed. Expected %s, Got %s\n", austrdup(temp), austrdup(udataDir)); } log_verbose("Testing UChars to chars\n"); charvalue=(char*)malloc(sizeof(char) * (u_strlen(udataDir) + 1)); u_UCharsToChars(udataDir, charvalue, (u_strlen(udataDir)+1)); if(strcmp(charvalue, dataDirectory) != 0){ log_err("ERROR: u_UCharsToChars failed. Expected %s, Got %s\n", charvalue, dataDirectory); } free(charvalue); free(udataDir); } log_verbose("Testing uprv_timezone()....\n"); { int32_t tzoffset = uprv_timezone(); log_verbose("Value returned from uprv_timezone = %d\n", tzoffset); if (tzoffset != 28800) { log_verbose("***** WARNING: If testing in the PST timezone, t_timezone should return 28800! *****"); } if ((tzoffset % 1800 != 0)) { log_err("FAIL: t_timezone may be incorrect. It is not a multiple of 30min."); } tzoffset=uprv_getUTCtime(); } }
void NumberFormatRoundTripTest::test(NumberFormat *fmt) { #if IEEE_754 && !defined(OS400) test(fmt, uprv_getNaN()); test(fmt, uprv_getInfinity()); test(fmt, -uprv_getInfinity()); #endif test(fmt, (int32_t)500); test(fmt, (int32_t)0); test(fmt, (int32_t)-0); test(fmt, 0.0); double negZero = 0.0; negZero /= -1.0; test(fmt, negZero); test(fmt, 9223372036854775808.0); test(fmt, -9223372036854775809.0); for(int i = 0; i < 10; ++i) { test(fmt, randomDouble(1)); test(fmt, randomDouble(10000)); test(fmt, uprv_floor((randomDouble(10000)))); test(fmt, randomDouble(1e50)); test(fmt, randomDouble(1e-50)); #if !defined(OS390) && !defined(OS400) test(fmt, randomDouble(1e100)); #elif IEEE_754 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) // 2) Parse the string into a double --> INF // 3) Re-format the double --> INF% // 4) The strings are equal, so that works. // 5) Calculate the proportional error --> INF, so the test will fail // I'll get around this by dividing by the multiplier to make sure // the double will stay in range. //if(fmt->getMultipler() == 1) if(fmt->getDynamicClassID() == DecimalFormat::getStaticClassID()) { #if !defined(OS390) && !defined(OS400) /* DBL_MAX/2 is here because randomDouble does a *2 in the math */ test(fmt, randomDouble(DBL_MAX/2.0) / ((DecimalFormat*)fmt)->getMultiplier()); #elif IEEE_754 test(fmt, randomDouble(1e75) / ((DecimalFormat*)fmt)->getMultiplier()); #else test(fmt, randomDouble(1e65) / ((DecimalFormat*)fmt)->getMultiplier()); /*OS390*/ #endif } #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) || defined(OS400) # if IEEE_754 test(fmt, randomDouble(1e-78)); /*OS390 and OS400*/ # endif #else test(fmt, randomDouble(1e-323)); #endif /* OS390 and OS400*/ #if !defined(OS390) && !defined(OS400) test(fmt, randomDouble(1e-100)); #elif IEEE_754 test(fmt, randomDouble(1e-78)); /*OS390 and OS400*/ #endif /* OS390 and OS400*/ } }
void ChoiceFormat::applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status) { if (U_FAILURE(status)) { return; } // Clear error struct parseError.offset = -1; parseError.preContext[0] = parseError.postContext[0] = (UChar)0; // Perform 2 passes. The first computes the number of limits in // this pattern (fCount), which is 1 more than the number of // literal VERTICAL_BAR characters. int32_t count = 1; int32_t i; for (i=0; i<pattern.length(); ++i) { UChar c = pattern[i]; if (c == SINGLE_QUOTE) { // Skip over the entire quote, including embedded // contiguous pairs of SINGLE_QUOTE. for (;;) { do { ++i; } while (i<pattern.length() && pattern[i] != SINGLE_QUOTE); if ((i+1)<pattern.length() && pattern[i+1] == SINGLE_QUOTE) { // SINGLE_QUOTE pair; skip over it ++i; } else { break; } } } else if (c == VERTICAL_BAR) { ++count; } } // Allocate the required storage. double *newLimits = (double*) uprv_malloc( sizeof(double) * count); /* test for NULL */ if (newLimits == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } UBool *newClosures = (UBool*) uprv_malloc( sizeof(UBool) * count); /* test for NULL */ if (newClosures == 0) { status = U_MEMORY_ALLOCATION_ERROR; uprv_free(newLimits); return; } UnicodeString *newFormats = new UnicodeString[count]; /* test for NULL */ if (newFormats == 0) { status = U_MEMORY_ALLOCATION_ERROR; uprv_free(newLimits); uprv_free(newClosures); return; } // Perform the second pass int32_t k = 0; // index into newXxx[] arrays UnicodeString buf; // scratch buffer UBool inQuote = FALSE; UBool inNumber = TRUE; // TRUE before < or #, FALSE after for (i=0; i<pattern.length(); ++i) { UChar c = pattern[i]; if (c == SINGLE_QUOTE) { // Check for SINGLE_QUOTE pair indicating a literal quote if ((i+1) < pattern.length() && pattern[i+1] == SINGLE_QUOTE) { buf += SINGLE_QUOTE; ++i; } else { inQuote = !inQuote; } } else if (inQuote) { buf += c; } else if (c == LESS_THAN || c == LESS_EQUAL || c == LESS_EQUAL2) { if (!inNumber || buf.length() == 0) { goto error; } inNumber = FALSE; double limit; buf.trim(); if (!buf.compare(gPositiveInfinity, POSITIVE_INF_STRLEN)) { limit = uprv_getInfinity(); } else if (!buf.compare(gNegativeInfinity, NEGATIVE_INF_STRLEN)) { limit = -uprv_getInfinity(); } else { limit = stod(buf); } if (k == count) { // This shouldn't happen. If it does, it means that // the count determined in the first pass did not // match the number of elements found in the second // pass. goto error; } newLimits[k] = limit; newClosures[k] = (c == LESS_THAN); if (k > 0 && limit <= newLimits[k-1]) { // Each limit must be strictly > than the previous // limit. One exception: Two subsequent limits may be // == if the first closure is FALSE and the second // closure is TRUE. This places the limit value in // the second interval. if (!(limit == newLimits[k-1] && !newClosures[k-1] && newClosures[k])) { goto error; } } buf.truncate(0); } else if (c == VERTICAL_BAR) { if (inNumber) { goto error; } inNumber = TRUE; newFormats[k] = buf; ++k; buf.truncate(0); } else { buf += c; } } if (k != (count-1) || inNumber || inQuote) { goto error; } newFormats[k] = buf; // Don't modify this object until the parse succeeds uprv_free(fChoiceLimits); uprv_free(fClosures); delete[] fChoiceFormats; fCount = count; fChoiceLimits = newLimits; fClosures = newClosures; fChoiceFormats = newFormats; return; error: status = U_ILLEGAL_ARGUMENT_ERROR; syntaxError(pattern,i,parseError); uprv_free(newLimits); uprv_free(newClosures); delete[] newFormats; return; }
void NumberFormatRoundTripTest::test(NumberFormat *fmt) { #if IEEE_754 && U_PLATFORM != U_PF_OS400 test(fmt, uprv_getNaN()); test(fmt, uprv_getInfinity()); test(fmt, -uprv_getInfinity()); #endif test(fmt, (int32_t)500); test(fmt, (int32_t)0); test(fmt, (int32_t)-0); test(fmt, 0.0); double negZero = 0.0; negZero /= -1.0; test(fmt, negZero); test(fmt, 9223372036854775808.0); test(fmt, -9223372036854775809.0); for(int i = 0; i < 10; ++i) { test(fmt, randomDouble(1)); test(fmt, randomDouble(10000)); test(fmt, uprv_floor((randomDouble(10000)))); test(fmt, randomDouble(1e50)); test(fmt, randomDouble(1e-50)); #if !(U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400) test(fmt, randomDouble(1e100)); #elif IEEE_754 test(fmt, randomDouble(1e75)); #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) // 2) Parse the string into a double --> INF // 3) Re-format the double --> INF% // 4) The strings are equal, so that works. // 5) Calculate the proportional error --> INF, so the test will fail // I'll get around this by dividing by the multiplier to make sure // the double will stay in range. //if(fmt->getMultipler() == 1) DecimalFormat *df = dynamic_cast<DecimalFormat *>(fmt); if(df != NULL) { #if !(U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400) /* DBL_MAX/2 is here because randomDouble does a *2 in the math */ test(fmt, randomDouble(DBL_MAX/2.0) / df->getMultiplier()); #elif IEEE_754 test(fmt, randomDouble(1e75) / df->getMultiplier()); #else test(fmt, randomDouble(1e65) / df->getMultiplier()); #endif } #if (defined(_MSC_VER) && _MSC_VER < 1400) || defined(__alpha__) || defined(U_OSF) // These machines and compilers don't fully support denormalized doubles, test(fmt, randomDouble(1e-292)); test(fmt, randomDouble(1e-100)); #elif U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400 // i5/OS (OS/400) throws exceptions on denormalized numbers # if IEEE_754 test(fmt, randomDouble(1e-78)); test(fmt, randomDouble(1e-78)); // #else we're using something like the old z/OS floating point. # endif #else // This is a normal machine that can support IEEE754 denormalized doubles without throwing an error. test(fmt, randomDouble(DBL_MIN)); /* Usually 2.2250738585072014e-308 */ test(fmt, randomDouble(1e-100)); #endif } }
void PUtilTest::testMaxMin() { double pinf = uprv_getInfinity(); double ninf = -uprv_getInfinity(); double nan = uprv_getNaN(); double pzero = 0.0; double nzero = 0.0; nzero *= -1; // +Inf with -Inf maxMinTest(pinf, ninf, pinf, TRUE); maxMinTest(pinf, ninf, ninf, FALSE); // +Inf with +0 and -0 maxMinTest(pinf, pzero, pinf, TRUE); maxMinTest(pinf, pzero, pzero, FALSE); maxMinTest(pinf, nzero, pinf, TRUE); maxMinTest(pinf, nzero, nzero, FALSE); // -Inf with +0 and -0 maxMinTest(ninf, pzero, pzero, TRUE); maxMinTest(ninf, pzero, ninf, FALSE); maxMinTest(ninf, nzero, nzero, TRUE); maxMinTest(ninf, nzero, ninf, FALSE); // NaN with +Inf and -Inf maxMinTest(pinf, nan, nan, TRUE); maxMinTest(pinf, nan, nan, FALSE); maxMinTest(ninf, nan, nan, TRUE); maxMinTest(ninf, nan, nan, FALSE); // NaN with NaN maxMinTest(nan, nan, nan, TRUE); maxMinTest(nan, nan, nan, FALSE); // NaN with +0 and -0 maxMinTest(nan, pzero, nan, TRUE); maxMinTest(nan, pzero, nan, FALSE); maxMinTest(nan, nzero, nan, TRUE); maxMinTest(nan, nzero, nan, FALSE); // +Inf with DBL_MAX and DBL_MIN maxMinTest(pinf, DBL_MAX, pinf, TRUE); maxMinTest(pinf, -DBL_MAX, pinf, TRUE); maxMinTest(pinf, DBL_MIN, pinf, TRUE); maxMinTest(pinf, -DBL_MIN, pinf, TRUE); maxMinTest(pinf, DBL_MIN, DBL_MIN, FALSE); maxMinTest(pinf, -DBL_MIN, -DBL_MIN, FALSE); maxMinTest(pinf, DBL_MAX, DBL_MAX, FALSE); maxMinTest(pinf, -DBL_MAX, -DBL_MAX, FALSE); // -Inf with DBL_MAX and DBL_MIN maxMinTest(ninf, DBL_MAX, DBL_MAX, TRUE); maxMinTest(ninf, -DBL_MAX, -DBL_MAX, TRUE); maxMinTest(ninf, DBL_MIN, DBL_MIN, TRUE); maxMinTest(ninf, -DBL_MIN, -DBL_MIN, TRUE); maxMinTest(ninf, DBL_MIN, ninf, FALSE); maxMinTest(ninf, -DBL_MIN, ninf, FALSE); maxMinTest(ninf, DBL_MAX, ninf, FALSE); maxMinTest(ninf, -DBL_MAX, ninf, FALSE); // +0 with DBL_MAX and DBL_MIN maxMinTest(pzero, DBL_MAX, DBL_MAX, TRUE); maxMinTest(pzero, -DBL_MAX, pzero, TRUE); maxMinTest(pzero, DBL_MIN, DBL_MIN, TRUE); maxMinTest(pzero, -DBL_MIN, pzero, TRUE); maxMinTest(pzero, DBL_MIN, pzero, FALSE); maxMinTest(pzero, -DBL_MIN, -DBL_MIN, FALSE); maxMinTest(pzero, DBL_MAX, pzero, FALSE); maxMinTest(pzero, -DBL_MAX, -DBL_MAX, FALSE); // -0 with DBL_MAX and DBL_MIN maxMinTest(nzero, DBL_MAX, DBL_MAX, TRUE); maxMinTest(nzero, -DBL_MAX, nzero, TRUE); maxMinTest(nzero, DBL_MIN, DBL_MIN, TRUE); maxMinTest(nzero, -DBL_MIN, nzero, TRUE); maxMinTest(nzero, DBL_MIN, nzero, FALSE); maxMinTest(nzero, -DBL_MIN, -DBL_MIN, FALSE); maxMinTest(nzero, DBL_MAX, nzero, FALSE); maxMinTest(nzero, -DBL_MAX, -DBL_MAX, FALSE); }
void IntlTestNumberFormat::testFormat(/* char* par */) { if (U_FAILURE(fStatus)) { dataerrln((UnicodeString)"**** FAIL: createXxxInstance failed. - " + u_errorName(fStatus)); if (fFormat != 0) errln("**** FAIL: Non-null format returned by createXxxInstance upon failure."); delete fFormat; fFormat = 0; return; } if (fFormat == 0) { errln((UnicodeString)"**** FAIL: Null format returned by createXxxInstance."); return; } UnicodeString str; // Assume it's a DecimalFormat and get some info DecimalFormat *s = (DecimalFormat*)fFormat; logln((UnicodeString)" Pattern " + s->toPattern(str)); #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 tryIt(9.29526819488338e+64); // Ok -- used to fail? #else tryIt(-2.02147304840132e-100); tryIt(3.88057859588817e-096); // Test rounding when only some digits are shown because exponent is close to -maxfrac tryIt(-2.64651110485945e+306); // Overflows to +INF when shown as a percent tryIt(9.29526819488338e+250); // Ok -- used to fail? #endif // These PASS now, with the sprintf/atof based format-parse. // These fail due to round-off // The least significant digit drops by one during each format-parse cycle. // Both numbers DON'T have a round-off problem when multiplied by 100! (shown as %) #ifdef OS390 tryIt(-9.18228054496402e+64); tryIt(-9.69413034454191e+64); #else tryIt(-9.18228054496402e+255); tryIt(-9.69413034454191e+273); #endif #ifndef OS390 tryIt(1.234e-200); tryIt(-2.3e-168); tryIt(uprv_getNaN()); tryIt(uprv_getInfinity()); tryIt(-uprv_getInfinity()); #endif tryIt((int32_t)251887531); tryIt(5e-20 / 9); tryIt(5e20 / 9); tryIt(1.234e-50); tryIt(9.99999999999996); tryIt(9.999999999999996); tryIt((int32_t)INT32_MIN); tryIt((int32_t)INT32_MAX); tryIt((double)INT32_MIN); tryIt((double)INT32_MAX); tryIt((double)INT32_MIN - 1.0); tryIt((double)INT32_MAX + 1.0); tryIt(5.0 / 9.0 * 1e-20); tryIt(4.0 / 9.0 * 1e-20); tryIt(5.0 / 9.0 * 1e+20); tryIt(4.0 / 9.0 * 1e+20); tryIt(2147483647.); tryIt((int32_t)0); tryIt(0.0); tryIt((int32_t)1); tryIt((int32_t)10); tryIt((int32_t)100); tryIt((int32_t)-1); tryIt((int32_t)-10); tryIt((int32_t)-100); tryIt((int32_t)-1913860352); for (int32_t z=0; z<10; ++z) { double d = randFraction() * 2e10 - 1e10; tryIt(d); } double it = getSafeDouble(100000.0); tryIt(0.0); tryIt(it); tryIt((int32_t)0); tryIt(uprv_floor(it)); tryIt((int32_t)randLong()); // try again it = getSafeDouble(100.0); tryIt(it); tryIt(uprv_floor(it)); tryIt((int32_t)randLong()); // try again with very large numbers it = getSafeDouble(100000000000.0); tryIt(it); // try again with very large numbers // and without going outside of the int32_t range it = randFraction() * INT32_MAX; tryIt(it); tryIt((int32_t)uprv_floor(it)); delete fFormat; }