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;
}
