/**
* Unit tests of PluralFormat class.
*/
void PluralFormatTest::pluralFormatUnitTest(/*char *par*/)
{
UnicodeString patternTestData[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE("odd {# is odd.} other{# is even.}"),
UNICODE_STRING_SIMPLE("other{# is odd or even.}"),
UNICODE_STRING_SIMPLE("odd{The number {0, number, #.#0} is odd.}other{The number {0, number, #.#0} is even.}"),
UNICODE_STRING_SIMPLE("odd{The number {1, number, #} is odd.}other{The number {2, number, #} is even.}"),
};
UnicodeString patternOddTestResult[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE(" is odd."),
UNICODE_STRING_SIMPLE(" is odd or even."),
UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is odd."),
UNICODE_STRING_SIMPLE("The number {1, number, #} is odd."),
};
UnicodeString patternEvenTestResult[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE(" is even."),
UNICODE_STRING_SIMPLE(" is odd or even."),
UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is even."),
UNICODE_STRING_SIMPLE("The number {2, number, #} is even."),
};
UnicodeString checkSyntaxtData[PLURAL_SYNTAX_DATA] = {
// ICU 4.8 does not check for duplicate keywords any more.
//UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
//UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
UNICODE_STRING_SIMPLE("odd{foo}"),
// ICU 4.8 does not check for unknown keywords any more.
//UNICODE_STRING_SIMPLE("otto{foo} other{bar}"),
UNICODE_STRING_SIMPLE("*odd{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
};
UErrorCode status = U_ZERO_ERROR;
UnicodeString oddAndEvenRule = UNICODE_STRING_SIMPLE("odd: n mod 2 is 1");
PluralRules* plRules = PluralRules::createRules(oddAndEvenRule, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: create PluralRules instance failed in unit tests.- exitting");
return;
}
// ======= Test PluralRules pattern syntax.
logln("Testing PluralRules pattern syntax.");
for (int32_t i=0; i<PLURAL_SYNTAX_DATA; ++i) {
status = U_ZERO_ERROR;
PluralFormat plFmt=PluralFormat(*plRules, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting");
return;
}
plFmt.applyPattern(checkSyntaxtData[i], status);
if (U_SUCCESS(status)) {
errln("ERROR: PluralFormat failed to detect syntax error with pattern: "+checkSyntaxtData[i]);
}
}
// ======= Test applying various pattern
logln("Testing various patterns");
status = U_ZERO_ERROR;
UBool overwrite[PLURAL_PATTERN_DATA] = {FALSE, FALSE, TRUE, TRUE};
NumberFormat *numFmt = NumberFormat::createInstance(status);
UnicodeString message=UnicodeString("ERROR: PluralFormat tests various pattern ...");
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat instance with default locale ");
}
for(int32_t i=0; i<PLURAL_PATTERN_DATA; ++i) {
status = U_ZERO_ERROR;
PluralFormat plFmt=PluralFormat(*plRules, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting");
return;
}
plFmt.applyPattern(patternTestData[i], status);
if (U_FAILURE(status)) {
errln("ERROR: PluralFormat failed to apply pattern- "+patternTestData[i]);
continue;
}
numberFormatTest(&plFmt, numFmt, 1, 10, (UnicodeString *)&patternOddTestResult[i],
(UnicodeString *)&patternEvenTestResult[i], overwrite[i], &message);
}
delete plRules;
delete numFmt;
// ======= Test set locale
status = U_ZERO_ERROR;
plRules = PluralRules::createRules(UNICODE_STRING_SIMPLE("odd: n mod 2 is 1"), status);
PluralFormat pluralFmt = PluralFormat(*plRules, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create PluralFormat instance in setLocale() test - exitting. ");
delete plRules;
return;
}
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd{odd} other{even}"), status);
pluralFmt.setLocale(Locale::getEnglish(), status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not setLocale() with English locale ");
delete plRules;
return;
}
message = UNICODE_STRING_SIMPLE("Error set locale: pattern is not reset!");
// Check that pattern gets deleted.
logln("\n Test setLocale() ..\n");
numFmt = NumberFormat::createInstance(Locale::getEnglish(), status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat instance with English locale ");
}
numberFormatTest(&pluralFmt, numFmt, 5, 5, NULL, NULL, FALSE, &message);
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd__{odd} other{even}"), status);
if (pluralFmt.format((int32_t)1, status) != UNICODE_STRING_SIMPLE("even")) {
errln("SetLocale should reset rules but did not.");
}
status = U_ZERO_ERROR;
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("one{one} other{not one}"), status);
if (U_FAILURE(status)) {
errln("SetLocale should reset rules but did not.");
}
UnicodeString one = UNICODE_STRING_SIMPLE("one");
UnicodeString notOne = UNICODE_STRING_SIMPLE("not one");
UnicodeString plResult, numResult;
for (int32_t i=0; i<20; ++i) {
plResult = pluralFmt.format(i, status);
if ( i==1 ) {
numResult = one;
}
else {
numResult = notOne;
}
if ( numResult != plResult ) {
errln("Wrong ruleset loaded by setLocale() - got:"+plResult+ UnicodeString(" expecting:")+numResult);
}
}
// =========== Test copy constructor
logln("Test copy constructor and == operator of PluralFormat");
PluralFormat dupPFmt = PluralFormat(pluralFmt);
if (pluralFmt != dupPFmt) {
errln("Failed in PluralFormat copy constructor or == operator");
}
delete plRules;
delete numFmt;
}
/**
* Test various generic API methods of PluralFormat for Basic usage.
*/
void PluralFormatTest::pluralFormatBasicTest(/*char *par*/)
{
UErrorCode status[8];
PluralFormat* plFmt[8];
Locale locale = Locale::getDefault();
UnicodeString otherPattern = UnicodeString("other{#}");
UnicodeString message=UnicodeString("ERROR: PluralFormat basic test");
// ========= Test constructors
logln(" Testing PluralFormat constructors ...");
status[0] = U_ZERO_ERROR;
PluralRules* plRules = PluralRules::createDefaultRules(status[0]);
status[0] = U_ZERO_ERROR;
NumberFormat *numFmt = NumberFormat::createInstance(status[0]);
if (U_FAILURE(status[0])) {
dataerrln("ERROR: Could not create NumberFormat instance with default locale ");
}
for (int32_t i=0; i< 8; ++i) {
status[i] = U_ZERO_ERROR;
}
plFmt[0] = new PluralFormat(status[0]);
plFmt[1] = new PluralFormat(*plRules, status[1]);
plFmt[2] = new PluralFormat(locale, status[2]);
plFmt[3] = new PluralFormat(locale, *plRules, status[3]);
plFmt[4] = new PluralFormat(otherPattern, status[4]);
plFmt[5] = new PluralFormat(*plRules, otherPattern, status[5]);
plFmt[6] = new PluralFormat(locale, otherPattern, status[6]);
plFmt[7] = new PluralFormat(locale, *plRules, otherPattern, status[7]);
for (int32_t i=0; i< 8; ++i) {
if (U_SUCCESS(status[i])) {
numberFormatTest(plFmt[i], numFmt, 1, 12, NULL, NULL, FALSE, &message);
numberFormatTest(plFmt[i], numFmt, 100, 112, NULL, NULL, FALSE, &message);
}
else {
dataerrln("ERROR: PluralFormat constructor failed!");
}
delete plFmt[i];
}
// ======= Test clone, assignment operator && == operator.
plFmt[0]= new PluralFormat(status[0]);
plFmt[0]->setNumberFormat(numFmt,status[0]);
UnicodeString us = UnicodeString("");
plFmt[0]->toPattern(us);
plFmt[1]= new PluralFormat(locale, status[1]);
if ( U_SUCCESS(status[0]) && U_SUCCESS(status[1]) ) {
*plFmt[1] = *plFmt[0];
if (plFmt[1]!=NULL) {
if ( *plFmt[1] != *plFmt[0] ) {
errln("ERROR: clone plural format test failed!");
}
}
}
else {
dataerrln("ERROR: PluralFormat constructor failed! - [0]%s [1]%s", u_errorName(status[0]), u_errorName(status[1]));
}
delete plFmt[0];
status[0] = U_ZERO_ERROR;
plFmt[0]= new PluralFormat(locale, status[0]);
if ( U_SUCCESS(status[0]) ) {
*plFmt[1] = *plFmt[0];
if (plFmt[1]!=NULL) {
if ( *plFmt[1] != *plFmt[0] ) {
errln("ERROR: assignment operator test failed!");
}
}
}
else {
dataerrln("ERROR: PluralFormat constructor failed! - %s", u_errorName(status[1]));
}
if ( U_SUCCESS(status[1]) ) {
plFmt[2] = (PluralFormat*) plFmt[1]->clone();
if (plFmt[1]!=NULL) {
if ( *plFmt[1] != *plFmt[2] ) {
errln("ERROR: clone function test failed!");
}
}
delete plFmt[1];
delete plFmt[2];
}
else {
dataerrln("ERROR: PluralFormat clone failed! - %s", u_errorName(status[1]));
}
delete plFmt[0];
delete numFmt;
delete plRules;
// Tests parseObject
UErrorCode stat = U_ZERO_ERROR;
PluralFormat *pf = new PluralFormat(stat);
Formattable *f = new Formattable();
ParsePosition *pp = new ParsePosition();
pf->parseObject((UnicodeString)"",*f,*pp);
if(U_FAILURE(stat)) {
dataerrln("ERROR: PluralFormat::parseObject: %s", u_errorName(stat));
}
delete pf;
delete f;
delete pp;
}
static void PluralFormatExample() {
u_printf("=============================================================================\n");
u_printf(" PluralFormatExample()\n");
u_printf("\n");
u_printf(" Use PluralFormat and Messageformat to get Plural Form for languages below:\n");
u_printf(" English, Slovenian\n");
u_printf("=============================================================================\n");
//! [PluralFormatExample]
UErrorCode status =U_ZERO_ERROR;
Locale locEn = Locale("en");
Locale locSl = Locale("sl");
UnicodeString patEn = UnicodeString("one{dog} other{dogs}"); // English 'dog'
UnicodeString patSl = UnicodeString("one{pes} two{psa} few{psi} other{psov}"); // Slovenian translation of dog in Plural Form
// Create a new PluralFormat for a given locale locale and pattern string
PluralFormat plfmtEn = PluralFormat(locEn, patEn,status);
PluralFormat plfmtSl = PluralFormat(locSl, patSl,status);
// Constructs a MessageFormat for given pattern and locale.
MessageFormat* msgfmtEn = new MessageFormat("{0,number} {1}", locEn,status);
MessageFormat* msgfmtSl = new MessageFormat("{0,number} {1}", locSl,status);
int numbers[] = {0, 1, 2, 3, 4, 5, 10, 100, 101, 102};
u_printf("Output by using PluralFormat and MessageFormat API\n");
u_printf("%-16s%-16s%-16s\n","Number", "English","Slovenian");
// Use MessageFormat.format () to format the objects and append to the given StringBuffer
for (int i=0;i<sizeof(numbers)/sizeof(int);i++) {
UnicodeString msgEn,msgSl;
FieldPosition fpos = 0;
Formattable argEn[]={Formattable(numbers[i]), Formattable(plfmtEn.format(numbers[i],status))};
Formattable argSl[]={Formattable(numbers[i]), Formattable(plfmtSl.format(numbers[i],status))};
msgfmtEn->format(argEn,2,msgEn,fpos,status);
msgfmtSl->format(argSl,2,msgSl,fpos,status);
u_printf("%-16d%-16S%-16S\n", numbers[i], msgEn.getTerminatedBuffer(),msgSl.getTerminatedBuffer());
}
u_printf("\n");
// Equivalent code with message format pattern
UnicodeString msgPatEn = "{0,plural, one{# dog} other{# dogs}}";
UnicodeString msgPatSl = "{0,plural, one{# pes} two{# psa} few{# psi} other{# psov}}";
MessageFormat* altMsgfmtEn = new MessageFormat(msgPatEn, locEn,status);
MessageFormat* altMsgfmtSl = new MessageFormat(msgPatSl, locSl,status);
u_printf("Same Output by using MessageFormat API only\n");
u_printf("%-16s%-16s%-16s\n","Number", "English","Slovenian");
for (int i=0;i<sizeof(numbers)/sizeof(int);i++) {
UnicodeString msgEn,msgSl;
Formattable arg[] = {numbers[i]};
FieldPosition fPos =0;
altMsgfmtEn->format(arg, 1, msgEn, fPos, status);
altMsgfmtSl->format(arg, 1, msgSl, fPos,status);
u_printf("%-16d%-16S%-16S\n", numbers[i], msgEn.getTerminatedBuffer(), msgSl.getTerminatedBuffer());
}
delete msgfmtEn;
delete msgfmtSl;
delete altMsgfmtEn;
delete altMsgfmtSl;
//! [PluralFormatExample]
/* output of the sample code:
********************************************************************
Number English Slovenian
0 0 dogs 0 psov
1 1 dog 1 pes
2 2 dogs 2 psa
3 3 dogs 3 psi
4 4 dogs 4 psi
5 5 dogs 5 psov
10 10 dogs 10 psov
100 100 dogs 100 psov
101 101 dogs 101 pes
102 102 dogs 102 psa
*********************************************************************/
}