942 lines
34 KiB
C++
942 lines
34 KiB
C++
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1997-1999, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
********************************************************************/
|
|
|
|
#include "msfmrgts.h"
|
|
|
|
#include "unicode/format.h"
|
|
#include "unicode/decimfmt.h"
|
|
#include "unicode/locid.h"
|
|
#include "unicode/msgfmt.h"
|
|
#include "unicode/numfmt.h"
|
|
#include "unicode/choicfmt.h"
|
|
#include "unicode/gregocal.h"
|
|
|
|
// *****************************************************************************
|
|
// class MessageFormatRegressionTest
|
|
// *****************************************************************************
|
|
|
|
#define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
|
|
|
|
void
|
|
MessageFormatRegressionTest::runIndexedTest( int32_t index, bool_t exec, char* &name, char* par )
|
|
{
|
|
// if (exec) logln((UnicodeString)"TestSuite MessageFormatRegressionTest");
|
|
switch (index) {
|
|
CASE(0,Test4074764)
|
|
CASE(1,Test4058973)
|
|
CASE(2,Test4031438)
|
|
CASE(3,Test4052223)
|
|
CASE(4,Test4104976)
|
|
CASE(5,Test4106659)
|
|
CASE(6,Test4106660)
|
|
CASE(7,Test4111739)
|
|
CASE(8,Test4114743)
|
|
CASE(9,Test4116444)
|
|
CASE(10,Test4114739)
|
|
CASE(11,Test4113018)
|
|
CASE(12,Test4106661)
|
|
CASE(13,Test4094906)
|
|
CASE(14,Test4118592)
|
|
CASE(15,Test4118594)
|
|
CASE(16,Test4105380)
|
|
CASE(17,Test4120552)
|
|
CASE(18,Test4142938)
|
|
CASE(19,TestChoicePatternQuote)
|
|
CASE(20,Test4112104);
|
|
|
|
default: name = ""; break;
|
|
}
|
|
}
|
|
|
|
bool_t
|
|
MessageFormatRegressionTest::failure(UErrorCode status, const char* msg)
|
|
{
|
|
if(U_FAILURE(status)) {
|
|
errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* @bug 4074764
|
|
* Null exception when formatting pattern with MessageFormat
|
|
* with no parameters.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4074764() {
|
|
UnicodeString pattern [] = {
|
|
"Message without param",
|
|
"Message with param:{0}",
|
|
"Longer Message with param {0}"
|
|
};
|
|
//difference between the two param strings are that
|
|
//in the first one, the param position is within the
|
|
//length of the string without param while it is not so
|
|
//in the other case.
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *messageFormatter = new MessageFormat("", status);
|
|
|
|
failure(status, "couldn't create MessageFormat");
|
|
|
|
//try {
|
|
//Apply pattern with param and print the result
|
|
messageFormatter->applyPattern(pattern[1], status);
|
|
failure(status, "messageFormat->applyPattern");
|
|
//Object[] params = {new UnicodeString("BUG"), new Date()};
|
|
Formattable params [] = {
|
|
Formattable(UnicodeString("BUG")),
|
|
Formattable(0, Formattable::kIsDate)
|
|
};
|
|
UnicodeString tempBuffer;
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
tempBuffer = messageFormatter->format(params, 2, tempBuffer, pos, status);
|
|
if( tempBuffer != "Message with param:BUG" || failure(status, "messageFormat->format"))
|
|
errln("MessageFormat with one param test failed.");
|
|
logln("Formatted with one extra param : " + tempBuffer);
|
|
|
|
//Apply pattern without param and print the result
|
|
messageFormatter->applyPattern(pattern[0], status);
|
|
failure(status, "messageFormatter->applyPattern");
|
|
|
|
// {sfb} how much does this apply in C++?
|
|
// do we want to verify that the Formattable* array is not NULL,
|
|
// or is that the user's responsibility?
|
|
// additionally, what should be the item count?
|
|
// for bug testing purposes, assume that something was set to
|
|
// NULL by mistake, and that the length should be non-zero
|
|
|
|
//tempBuffer = messageFormatter->format(NULL, 1, tempBuffer, FieldPosition(FieldPosition::DONT_CARE), status);
|
|
tempBuffer.remove();
|
|
tempBuffer = messageFormatter->format(NULL, 0, tempBuffer, pos, status);
|
|
|
|
if( tempBuffer != "Message without param" || failure(status, "messageFormat->format"))
|
|
errln("MessageFormat with no param test failed.");
|
|
logln("Formatted with no params : " + tempBuffer);
|
|
|
|
tempBuffer.remove();
|
|
tempBuffer = messageFormatter->format(params, 2, tempBuffer, pos, status);
|
|
if (tempBuffer != "Message without param" || failure(status, "messageFormat->format"))
|
|
errln("Formatted with arguments > subsitution failed. result = " + tempBuffer);
|
|
logln("Formatted with extra params : " + tempBuffer);
|
|
//This statement gives an exception while formatting...
|
|
//If we use pattern[1] for the message with param,
|
|
//we get an NullPointerException in MessageFormat.java(617)
|
|
//If we use pattern[2] for the message with param,
|
|
//we get an StringArrayIndexOutOfBoundsException in MessageFormat.java(614)
|
|
//Both are due to maxOffset not being reset to -1
|
|
//in applyPattern() when the pattern does not
|
|
//contain any param.
|
|
/*} catch (Exception foo) {
|
|
errln("Exception when formatting with no params.");
|
|
}*/
|
|
|
|
delete messageFormatter;
|
|
}
|
|
|
|
/* @bug 4058973
|
|
* MessageFormat.toPattern has weird rounding behavior.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4058973()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *fmt = new MessageFormat("{0,choice,0#no files|1#one file|1< {0,number,integer} files}", status);
|
|
failure(status, "new MessageFormat");
|
|
|
|
UnicodeString pat;
|
|
pat = fmt->toPattern(pat);
|
|
UnicodeString exp("{0,choice,0.0#no files|1.0#one file|1.0< {0,number,integer} files}");
|
|
if (pat != exp) {
|
|
errln("MessageFormat.toPattern failed");
|
|
errln("Exp: " + exp);
|
|
errln("Got: " + pat);
|
|
}
|
|
|
|
delete fmt;
|
|
}
|
|
/* @bug 4031438
|
|
* More robust message formats.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4031438()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
UnicodeString pattern1("Impossible {1} has occurred -- status code is {0} and message is {2}.");
|
|
UnicodeString pattern2("Double '' Quotes {0} test and quoted '{1}' test plus 'other {2} stuff'.");
|
|
|
|
MessageFormat *messageFormatter = new MessageFormat("", status);
|
|
failure(status, "new MessageFormat");
|
|
|
|
//try {
|
|
logln("Apply with pattern : " + pattern1);
|
|
messageFormatter->applyPattern(pattern1, status);
|
|
failure(status, "messageFormat->applyPattern");
|
|
//Object[] params = {new Integer(7)};
|
|
Formattable params []= {
|
|
Formattable((int32_t)7)
|
|
};
|
|
UnicodeString tempBuffer;
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
tempBuffer = messageFormatter->format(params, 1, tempBuffer, pos, status);
|
|
if(tempBuffer != "Impossible {1} has occurred -- status code is 7 and message is {2}." || failure(status, "MessageFormat::format"))
|
|
errln("Tests arguments < substitution failed");
|
|
logln("Formatted with 7 : " + tempBuffer);
|
|
ParsePosition pp(0);
|
|
int32_t count = 0;
|
|
Formattable *objs = messageFormatter->parse(tempBuffer, pp, count);
|
|
//if(objs[7/*params.length*/] != NULL)
|
|
// errln("Parse failed with more than expected arguments");
|
|
|
|
NumberFormat *fmt = 0;
|
|
UnicodeString temp, temp1;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
// convert to string if not already
|
|
Formattable obj = objs[i];
|
|
temp.remove();
|
|
if(obj.getType() == Formattable::kString)
|
|
temp = obj.getString(temp);
|
|
else {
|
|
fmt = NumberFormat::createInstance(status);
|
|
fmt->format(obj.getType() == Formattable::kLong ? obj.getLong() : obj.getDouble(), temp);
|
|
}
|
|
|
|
// convert to string if not already
|
|
Formattable obj1 = params[i];
|
|
temp1.remove();
|
|
if(obj1.getType() == Formattable::kDouble || obj1.getType() == Formattable::kLong) {
|
|
fmt = NumberFormat::createInstance(status);
|
|
fmt->format(obj1.getType() == Formattable::kLong ? obj1.getLong() : obj1.getDouble(), temp1);
|
|
}
|
|
else
|
|
temp1 = obj1.getString(temp1);
|
|
|
|
//if (objs[i] != NULL && objs[i].getString(temp1) != params[i].getString(temp2)) {
|
|
if (temp != temp1) {
|
|
errln("Parse failed on object " + objs[i].getString(temp1) + " at index : " + i);
|
|
}
|
|
|
|
}
|
|
|
|
delete fmt;
|
|
delete [] objs;
|
|
|
|
// {sfb} does this apply? no way to really pass a null Formattable,
|
|
// only a null array
|
|
|
|
/*tempBuffer = messageFormatter->format(null, tempBuffer, FieldPosition(FieldPosition::DONT_CARE), status);
|
|
if (tempBuffer != "Impossible {1} has occurred -- status code is {0} and message is {2}." || failure(status, "messageFormat->format"))
|
|
errln("Tests with no arguments failed");
|
|
logln("Formatted with null : " + tempBuffer);*/
|
|
logln("Apply with pattern : " + pattern2);
|
|
messageFormatter->applyPattern(pattern2, status);
|
|
failure(status, "messageFormatter->applyPattern");
|
|
tempBuffer.remove();
|
|
tempBuffer = messageFormatter->format(params, 1, tempBuffer, pos, status);
|
|
if (tempBuffer != "Double ' Quotes 7 test and quoted {1} test plus other {2} stuff.")
|
|
errln("quote format test (w/ params) failed.");
|
|
logln("Formatted with params : " + tempBuffer);
|
|
|
|
/*tempBuffer = messageFormatter->format(null);
|
|
if (!tempBuffer.equals("Double ' Quotes {0} test and quoted {1} test plus other {2} stuff."))
|
|
errln("quote format test (w/ null) failed.");
|
|
logln("Formatted with null : " + tempBuffer);
|
|
logln("toPattern : " + messageFormatter.toPattern());*/
|
|
/*} catch (Exception foo) {
|
|
errln("Exception when formatting in bug 4031438. "+foo.getMessage());
|
|
}*/
|
|
}
|
|
|
|
void MessageFormatRegressionTest::Test4052223()
|
|
{
|
|
|
|
ParsePosition pos(0);
|
|
if (pos.getErrorIndex() != -1) {
|
|
errln("ParsePosition.getErrorIndex initialization failed.");
|
|
}
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *fmt = new MessageFormat("There are {0} apples growing on the {1} tree.", status);
|
|
failure(status, "new MessageFormat");
|
|
UnicodeString str("There is one apple growing on the peach tree.");
|
|
|
|
int32_t count = 0;
|
|
Formattable *objs = fmt->parse(str, pos, count);
|
|
|
|
logln(UnicodeString("unparsable string , should fail at ") + pos.getErrorIndex());
|
|
if (pos.getErrorIndex() == -1)
|
|
errln("Bug 4052223 failed : parsing string " + str);
|
|
pos.setErrorIndex(4);
|
|
if (pos.getErrorIndex() != 4)
|
|
errln(UnicodeString("setErrorIndex failed, got ") + pos.getErrorIndex() + " instead of 4");
|
|
|
|
ChoiceFormat *f = 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");
|
|
pos.setIndex(0);
|
|
pos.setErrorIndex(-1);
|
|
Formattable obj;
|
|
f->parse("are negative", obj, pos);
|
|
if (pos.getErrorIndex() != -1 && obj.getDouble() == -1.0)
|
|
errln(UnicodeString("Parse with \"are negative\" failed, at ") + pos.getErrorIndex());
|
|
pos.setIndex(0);
|
|
pos.setErrorIndex(-1);
|
|
f->parse("are no or fraction ", obj, pos);
|
|
if (pos.getErrorIndex() != -1 && obj.getDouble() == 0.0)
|
|
errln(UnicodeString("Parse with \"are no or fraction\" failed, at ") + pos.getErrorIndex());
|
|
pos.setIndex(0);
|
|
pos.setErrorIndex(-1);
|
|
f->parse("go postal", obj, pos);
|
|
if (pos.getErrorIndex() == -1 && ! uprv_isNaN(obj.getDouble()))
|
|
errln(UnicodeString("Parse with \"go postal\" failed, at ") + pos.getErrorIndex());
|
|
|
|
delete fmt;
|
|
delete f;
|
|
}
|
|
/* @bug 4104976
|
|
* ChoiceFormat.equals(null) throws NullPointerException
|
|
*/
|
|
|
|
// {sfb} not really applicable in C++?? (kind of silly)
|
|
|
|
void MessageFormatRegressionTest::Test4104976()
|
|
{
|
|
double limits [] = {1, 20};
|
|
UnicodeString formats [] = {
|
|
UnicodeString("xyz"),
|
|
UnicodeString("abc")
|
|
};
|
|
int32_t formats_length = sizeof(formats)/sizeof(formats[0]);
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
ChoiceFormat *cf = new ChoiceFormat(limits, formats, formats_length);
|
|
failure(status, "new ChoiceFormat");
|
|
//try {
|
|
log("Compares to null is always false, returned : ");
|
|
logln(cf == NULL ? "TRUE" : "FALSE");
|
|
/*} catch (Exception foo) {
|
|
errln("ChoiceFormat.equals(null) throws exception.");
|
|
}*/
|
|
|
|
delete cf;
|
|
}
|
|
|
|
/* @bug 4106659
|
|
* ChoiceFormat.ctor(double[], String[]) doesn't check
|
|
* whether lengths of input arrays are equal.
|
|
*/
|
|
|
|
// {sfb} again, not really applicable in C++
|
|
|
|
void MessageFormatRegressionTest::Test4106659()
|
|
{
|
|
/*
|
|
double limits [] = {
|
|
1, 2, 3
|
|
};
|
|
UnicodeString formats [] = {
|
|
"one", "two"
|
|
};
|
|
ChoiceFormat *cf = NULL;
|
|
//try {
|
|
// cf = new ChoiceFormat(limits, formats, 3);
|
|
//} catch (Exception foo) {
|
|
// logln("ChoiceFormat constructor should check for the array lengths");
|
|
// cf = null;
|
|
//}
|
|
//if (cf != null)
|
|
// errln(cf->format(5));
|
|
//
|
|
delete cf;
|
|
*/
|
|
}
|
|
|
|
/* @bug 4106660
|
|
* ChoiceFormat.ctor(double[], String[]) allows unordered double array.
|
|
* This is not a bug, added javadoc to emphasize the use of limit
|
|
* array must be in ascending order.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4106660()
|
|
{
|
|
double limits [] = {3, 1, 2};
|
|
UnicodeString formats [] = {
|
|
UnicodeString("Three"),
|
|
UnicodeString("One"),
|
|
UnicodeString("Two")
|
|
};
|
|
ChoiceFormat *cf = new ChoiceFormat(limits, formats, 3);
|
|
double d = 5.0;
|
|
UnicodeString str;
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
str = cf->format(d, str, pos);
|
|
if (str != "Two")
|
|
errln( (UnicodeString) "format(" + d + ") = " + str);
|
|
|
|
delete cf;
|
|
}
|
|
|
|
/* @bug 4111739
|
|
* MessageFormat is incorrectly serialized/deserialized.
|
|
*/
|
|
|
|
// {sfb} doesn't apply in C++
|
|
|
|
void MessageFormatRegressionTest::Test4111739()
|
|
{
|
|
/*MessageFormat format1 = null;
|
|
MessageFormat format2 = null;
|
|
ObjectOutputStream ostream = null;
|
|
ByteArrayOutputStream baos = null;
|
|
ObjectInputStream istream = null;
|
|
|
|
try {
|
|
baos = new ByteArrayOutputStream();
|
|
ostream = new ObjectOutputStream(baos);
|
|
} catch(IOException e) {
|
|
errln("Unexpected exception : " + e.getMessage());
|
|
return;
|
|
}
|
|
|
|
try {
|
|
format1 = new MessageFormat("pattern{0}");
|
|
ostream.writeObject(format1);
|
|
ostream.flush();
|
|
|
|
byte bytes[] = baos.toByteArray();
|
|
|
|
istream = new ObjectInputStream(new ByteArrayInputStream(bytes));
|
|
format2 = (MessageFormat)istream.readObject();
|
|
} catch(Exception e) {
|
|
errln("Unexpected exception : " + e.getMessage());
|
|
}
|
|
|
|
if (!format1.equals(format2)) {
|
|
errln("MessageFormats before and after serialization are not" +
|
|
" equal\nformat1 = " + format1 + "(" + format1.toPattern() + ")\nformat2 = " +
|
|
format2 + "(" + format2.toPattern() + ")");
|
|
} else {
|
|
logln("Serialization for MessageFormat is OK.");
|
|
}*/
|
|
}
|
|
/* @bug 4114743
|
|
* MessageFormat.applyPattern allows illegal patterns.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4114743()
|
|
{
|
|
UnicodeString originalPattern("initial pattern");
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat(originalPattern, status);
|
|
failure(status, "new MessageFormat");
|
|
//try {
|
|
UnicodeString illegalPattern("ab { '}' de");
|
|
mf->applyPattern(illegalPattern, status);
|
|
if( ! U_FAILURE(status))
|
|
errln("illegal pattern: \"" + illegalPattern + "\"");
|
|
/*} catch (IllegalArgumentException foo) {
|
|
if (!originalPattern.equals(mf.toPattern()))
|
|
errln("pattern after: \"" + mf.toPattern() + "\"");
|
|
}*/
|
|
}
|
|
|
|
/* @bug 4116444
|
|
* MessageFormat.parse has different behavior in case of null.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4116444()
|
|
{
|
|
UnicodeString patterns [] = {
|
|
(UnicodeString)"",
|
|
(UnicodeString)"one",
|
|
(UnicodeString) "{0,date,short}"
|
|
};
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat("", status);
|
|
failure(status, "new MessageFormat");
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
UnicodeString pattern = patterns[i];
|
|
mf->applyPattern(pattern, status);
|
|
failure(status, "mf->applyPattern");
|
|
|
|
//try {
|
|
int32_t count = 0;
|
|
ParsePosition pp(0);
|
|
Formattable *array = mf->parse(UnicodeString(""), pp, count);
|
|
logln("pattern: \"" + pattern + "\"");
|
|
log(" parsedObjects: ");
|
|
if (array != NULL) {
|
|
log("{");
|
|
for (int j = 0; j < count; j++) {
|
|
//if (array[j] != null)
|
|
UnicodeString dummy;
|
|
err("\"" + array[j].getString(dummy) + "\"");
|
|
//else
|
|
// log("null");
|
|
if (j < count- 1)
|
|
log(",");
|
|
}
|
|
log("}") ;
|
|
} else {
|
|
log("null");
|
|
}
|
|
logln("");
|
|
/*} catch (Exception e) {
|
|
errln("pattern: \"" + pattern + "\"");
|
|
errln(" Exception: " + e.getMessage());
|
|
}*/
|
|
}
|
|
|
|
delete mf;
|
|
}
|
|
/* @bug 4114739 (FIX and add javadoc)
|
|
* MessageFormat.format has undocumented behavior about empty format objects.
|
|
*/
|
|
|
|
// {sfb} doesn't apply in C++?
|
|
void MessageFormatRegressionTest::Test4114739()
|
|
{
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat("<{0}>", status);
|
|
failure(status, "new MessageFormat");
|
|
|
|
Formattable *objs1 = NULL;
|
|
//Formattable objs2 [] = {};
|
|
//Formattable *objs3 [] = {NULL};
|
|
//try {
|
|
UnicodeString pat;
|
|
UnicodeString res;
|
|
logln("pattern: \"" + mf->toPattern(pat) + "\"");
|
|
log("format(null) : ");
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
logln("\"" + mf->format(objs1, 0, res, pos, status) + "\"");
|
|
failure(status, "mf->format");
|
|
/*log("format({}) : ");
|
|
logln("\"" + mf->format(objs2, 0, res, FieldPosition(FieldPosition::DONT_CARE), status) + "\"");
|
|
failure(status, "mf->format");
|
|
log("format({null}) :");
|
|
logln("\"" + mf->format(objs3, 0, res, FieldPosition(FieldPosition::DONT_CARE), status) + "\"");
|
|
failure(status, "mf->format");*/
|
|
/*} catch (Exception e) {
|
|
errln("Exception thrown for null argument tests.");
|
|
}*/
|
|
|
|
delete mf;
|
|
}
|
|
|
|
/* @bug 4113018
|
|
* MessageFormat.applyPattern works wrong with illegal patterns.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4113018()
|
|
{
|
|
UnicodeString originalPattern("initial pattern");
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat(originalPattern, status);
|
|
failure(status, "new messageFormat");
|
|
UnicodeString illegalPattern("format: {0, xxxYYY}");
|
|
UnicodeString pat;
|
|
logln("pattern before: \"" + mf->toPattern(pat) + "\"");
|
|
logln("illegal pattern: \"" + illegalPattern + "\"");
|
|
//try {
|
|
mf->applyPattern(illegalPattern, status);
|
|
if( ! U_FAILURE(status))
|
|
errln("Should have thrown IllegalArgumentException for pattern : " + illegalPattern);
|
|
/*} catch (IllegalArgumentException e) {
|
|
if (!originalPattern.equals(mf.toPattern()))
|
|
errln("pattern after: \"" + mf.toPattern() + "\"");
|
|
}*/
|
|
delete mf;
|
|
}
|
|
|
|
/* @bug 4106661
|
|
* ChoiceFormat is silent about the pattern usage in javadoc.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/* @bug 4094906
|
|
* ChoiceFormat should accept \u221E as eq. to INF.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4094906()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UnicodeString pattern("-");
|
|
pattern += (UChar) 0x221E;
|
|
pattern += "<are negative|0.0<are no or fraction|1.0#is one|1.0<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;
|
|
}
|
|
|
|
/* @bug 4118592
|
|
* MessageFormat.parse fails with ChoiceFormat.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4118592()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat("", status);
|
|
failure(status, "new messageFormat");
|
|
UnicodeString pattern("{0,choice,1#YES|2#NO}");
|
|
UnicodeString prefix("");
|
|
Formattable *objs = 0;
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
UnicodeString formatted;
|
|
formatted = prefix + "YES";
|
|
mf->applyPattern(prefix + pattern, status);
|
|
failure(status, "mf->applyPattern");
|
|
prefix += "x";
|
|
//Object[] objs = mf.parse(formatted, new ParsePosition(0));
|
|
int32_t count = 0;
|
|
ParsePosition pp(0);
|
|
objs = mf->parse(formatted, pp, count);
|
|
UnicodeString pat;
|
|
logln(UnicodeString("") + i + ". pattern :\"" + mf->toPattern(pat) + "\"");
|
|
log(" \"" + formatted + "\" parsed as ");
|
|
if (objs == NULL)
|
|
logln(" null");
|
|
else {
|
|
UnicodeString temp;
|
|
if(objs[0].getType() == Formattable::kString)
|
|
logln((UnicodeString)" " + objs[0].getString(temp));
|
|
else
|
|
logln((UnicodeString)" " + (objs[0].getType() == Formattable::kLong ? objs[0].getLong() : objs[0].getDouble()));
|
|
|
|
}
|
|
}
|
|
|
|
delete [] objs;
|
|
delete mf;
|
|
}
|
|
/* @bug 4118594
|
|
* MessageFormat.parse fails for some patterns.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4118594()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat("{0}, {0}, {0}", status);
|
|
failure(status, "new MessageFormat");
|
|
UnicodeString forParsing("x, y, z");
|
|
//Object[] objs = mf.parse(forParsing, new ParsePosition(0));
|
|
int32_t count = 0;
|
|
ParsePosition pp(0);
|
|
Formattable *objs = mf->parse(forParsing, pp, count);
|
|
UnicodeString pat;
|
|
logln("pattern: \"" + mf->toPattern(pat) + "\"");
|
|
logln("text for parsing: \"" + forParsing + "\"");
|
|
UnicodeString str;
|
|
if (objs[0].getString(str) != "z")
|
|
errln("argument0: \"" + objs[0].getString(str) + "\"");
|
|
mf->applyPattern("{0,number,#.##}, {0,number,#.#}", status);
|
|
failure(status, "mf->applyPattern");
|
|
//Object[] oldobjs = {new Double(3.1415)};
|
|
Formattable oldobjs [] = {Formattable(3.1415)};
|
|
UnicodeString result;
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
result = mf->format( oldobjs, 1, result, pos, status );
|
|
failure(status, "mf->format");
|
|
pat.remove();
|
|
logln("pattern: \"" + mf->toPattern(pat) + "\"");
|
|
logln("text for parsing: \"" + result + "\"");
|
|
// result now equals "3.14, 3.1"
|
|
if (result != "3.14, 3.1")
|
|
errln("result = " + result);
|
|
//Object[] newobjs = mf.parse(result, new ParsePosition(0));
|
|
int32_t count1 = 0;
|
|
pp.setIndex(0);
|
|
Formattable *newobjs = mf->parse(result, pp, count1);
|
|
// newobjs now equals {new Double(3.1)}
|
|
if (newobjs[0].getDouble() != 3.1)
|
|
errln( UnicodeString("newobjs[0] = ") + newobjs[0].getDouble());
|
|
|
|
delete [] objs;
|
|
delete [] newobjs;
|
|
delete mf;
|
|
}
|
|
/* @bug 4105380
|
|
* When using ChoiceFormat, MessageFormat is not good for I18n.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4105380()
|
|
{
|
|
UnicodeString patternText1("The disk \"{1}\" contains {0}.");
|
|
UnicodeString patternText2("There are {0} on the disk \"{1}\"");
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *form1 = new MessageFormat(patternText1, status);
|
|
failure(status, "new MessageFormat");
|
|
MessageFormat *form2 = new MessageFormat(patternText2, status);
|
|
failure(status, "new MessageFormat");
|
|
double filelimits [] = {0,1,2};
|
|
UnicodeString filepart [] = {
|
|
(UnicodeString)"no files",
|
|
(UnicodeString)"one file",
|
|
(UnicodeString)"{0,number} files"
|
|
};
|
|
ChoiceFormat *fileform = new ChoiceFormat(filelimits, filepart, 3);
|
|
form1->setFormat(1, *fileform);
|
|
form2->setFormat(0, *fileform);
|
|
//Object[] testArgs = {new Long(12373), "MyDisk"};
|
|
Formattable testArgs [] = {
|
|
Formattable((int32_t)12373),
|
|
Formattable((UnicodeString)"MyDisk")
|
|
};
|
|
|
|
FieldPosition bogus(FieldPosition::DONT_CARE);
|
|
|
|
UnicodeString result;
|
|
logln(form1->format(testArgs, 2, result, bogus, status));
|
|
failure(status, "form1->format");
|
|
result.remove();
|
|
logln(form2->format(testArgs, 2, result, bogus, status));
|
|
failure(status, "form1->format");
|
|
|
|
delete form1;
|
|
delete form2;
|
|
delete fileform;
|
|
}
|
|
/* @bug 4120552
|
|
* MessageFormat.parse incorrectly sets errorIndex.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4120552()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat("pattern", status);
|
|
failure(status, "new MessageFormat");
|
|
UnicodeString texts[] = {
|
|
(UnicodeString)"pattern",
|
|
(UnicodeString)"pat",
|
|
(UnicodeString)"1234"
|
|
};
|
|
UnicodeString pat;
|
|
logln("pattern: \"" + mf->toPattern(pat) + "\"");
|
|
for (int i = 0; i < 3; i++) {
|
|
ParsePosition pp(0);
|
|
//Object[] objs = mf.parse(texts[i], pp);
|
|
int32_t count = 0;
|
|
Formattable *objs = mf->parse(texts[i], pp, count);
|
|
log(" text for parsing: \"" + texts[i] + "\"");
|
|
if (objs == NULL) {
|
|
logln(" (incorrectly formatted string)");
|
|
if (pp.getErrorIndex() == -1)
|
|
errln(UnicodeString("Incorrect error index: ") + pp.getErrorIndex());
|
|
} else {
|
|
logln(" (correctly formatted string)");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @bug 4142938
|
|
* MessageFormat handles single quotes in pattern wrong.
|
|
* This is actually a problem in ChoiceFormat; it doesn't
|
|
* understand single quotes.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4142938()
|
|
{
|
|
UnicodeString pat = CharsToUnicodeString("''Vous'' {0,choice,0#n''|1#}avez s\\u00E9lectionn\\u00E9 "
|
|
"{0,choice,0#aucun|1#{0}} client{0,choice,0#s|1#|2#s} "
|
|
"personnel{0,choice,0#s|1#|2#s}.");
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *mf = new MessageFormat(pat, status);
|
|
failure(status, "new MessageFormat");
|
|
|
|
UnicodeString PREFIX [] = {
|
|
CharsToUnicodeString("'Vous' n'avez s\\u00E9lectionn\\u00E9 aucun clients personnels."),
|
|
CharsToUnicodeString("'Vous' avez s\\u00E9lectionn\\u00E9 "),
|
|
CharsToUnicodeString("'Vous' avez s\\u00E9lectionn\\u00E9 ")
|
|
};
|
|
UnicodeString SUFFIX [] = {
|
|
UnicodeString(),
|
|
UNICODE_STRING(" client personnel.", 18),
|
|
UNICODE_STRING(" clients personnels.", 20)
|
|
};
|
|
|
|
for (int i=0; i<3; i++) {
|
|
UnicodeString out;
|
|
//out = mf->format(new Object[]{new Integer(i)});
|
|
Formattable objs [] = {
|
|
Formattable((int32_t)i)
|
|
};
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
out = mf->format(objs, 1, out, pos, status);
|
|
failure(status, "mf->format");
|
|
if (SUFFIX[i] == "") {
|
|
if (out != PREFIX[i])
|
|
errln((UnicodeString)"" + i + ": Got \"" + out + "\"; Want \"" + PREFIX[i] + "\"");
|
|
}
|
|
else {
|
|
if (!out.startsWith(PREFIX[i]) ||
|
|
!out.endsWith(SUFFIX[i]))
|
|
errln((UnicodeString)"" + i + ": Got \"" + out + "\"; Want \"" + PREFIX[i] + "\"...\"" +
|
|
SUFFIX[i] + "\"");
|
|
}
|
|
}
|
|
|
|
delete mf;
|
|
}
|
|
|
|
/**
|
|
* @bug 4142938
|
|
* Test the applyPattern and toPattern handling of single quotes
|
|
* by ChoiceFormat. (This is in here because this was a bug reported
|
|
* against MessageFormat.) The single quote is used to quote the
|
|
* pattern characters '|', '#', '<', and '\u2264'. Two quotes in a row
|
|
* is a quote literal.
|
|
*/
|
|
void MessageFormatRegressionTest::TestChoicePatternQuote()
|
|
{
|
|
UnicodeString DATA [] = {
|
|
// Pattern 0 value 1 value
|
|
// {sfb} hacked - changed \u2264 to = (copied from Character Map)
|
|
(UnicodeString)"0#can''t|1#can", (UnicodeString)"can't", (UnicodeString)"can",
|
|
(UnicodeString)"0#'pound(#)=''#'''|1#xyz", (UnicodeString)"pound(#)='#'", (UnicodeString)"xyz",
|
|
(UnicodeString)"0#'1<2 | 1=1'|1#''", (UnicodeString)"1<2 | 1=1", (UnicodeString)"'",
|
|
};
|
|
for (int i=0; i<9; i+=3) {
|
|
//try {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
ChoiceFormat *cf = new ChoiceFormat(DATA[i], status);
|
|
failure(status, "new ChoiceFormat");
|
|
for (int j=0; j<=1; ++j) {
|
|
UnicodeString out;
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
out = cf->format((double)j, out, pos);
|
|
if (out != DATA[i+1+j])
|
|
errln("Fail: Pattern \"" + DATA[i] + "\" x "+j+" -> " +
|
|
out + "; want \"" + DATA[i+1+j] + '"');
|
|
}
|
|
UnicodeString pat;
|
|
pat = cf->toPattern(pat);
|
|
UnicodeString pat2;
|
|
ChoiceFormat *cf2 = new ChoiceFormat(pat, status);
|
|
pat2 = cf2->toPattern(pat2);
|
|
if (pat != pat2)
|
|
errln("Fail: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + '"');
|
|
else
|
|
logln("Ok: Pattern \"" + DATA[i] + "\" x toPattern -> \"" + pat + '"');
|
|
/*}
|
|
catch (IllegalArgumentException e) {
|
|
errln("Fail: Pattern \"" + DATA[i] + "\" -> " + e);
|
|
}*/
|
|
|
|
delete cf;
|
|
delete cf2;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @bug 4112104
|
|
* MessageFormat.equals(null) throws a NullPointerException. The JLS states
|
|
* that it should return false.
|
|
*/
|
|
void MessageFormatRegressionTest::Test4112104()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
MessageFormat *format = new MessageFormat("", status);
|
|
failure(status, "new MessageFormat");
|
|
//try {
|
|
// This should NOT throw an exception
|
|
if (format == NULL) {
|
|
// It also should return false
|
|
errln("MessageFormat.equals(null) returns false");
|
|
}
|
|
/*}
|
|
catch (NullPointerException e) {
|
|
errln("MessageFormat.equals(null) throws " + e);
|
|
}*/
|
|
}
|
|
|