Index: source/test/intltest/plurfmts.cpp |
diff --git a/source/test/intltest/plurfmts.cpp b/source/test/intltest/plurfmts.cpp |
deleted file mode 100644 |
index 5ed80208d075556250769dc4ca9954f4517e86f0..0000000000000000000000000000000000000000 |
--- a/source/test/intltest/plurfmts.cpp |
+++ /dev/null |
@@ -1,782 +0,0 @@ |
-/******************************************************************** |
- * COPYRIGHT: |
- * Copyright (c) 2007-2013, International Business Machines Corporation and |
- * others. All Rights Reserved. |
- ********************************************************************/ |
- |
-#include "unicode/utypes.h" |
- |
-#if !UCONFIG_NO_FORMATTING |
- |
-#include "unicode/dcfmtsym.h" |
-#include "unicode/decimfmt.h" |
-#include "unicode/msgfmt.h" |
-#include "unicode/plurfmt.h" |
-#include "unicode/plurrule.h" |
-#include "cmemory.h" |
-#include "plurfmts.h" |
-#include "plurults.h" |
- |
-#define PLURAL_PATTERN_DATA 4 |
-#define PLURAL_TEST_ARRAY_SIZE 256 |
- |
-#define PLURAL_SYNTAX_DATA 8 |
- |
-// The value must be same as PLKeywordLookups[] order. |
-#define PFT_ZERO 0 |
-#define PFT_ONE 1 |
-#define PFT_TWO 2 |
-#define PFT_FEW 3 |
-#define PFT_MANY 4 |
-#define PFT_OTHER 5 |
- |
-void PluralFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) |
-{ |
- if (exec) logln("TestSuite PluralFormat"); |
- TESTCASE_AUTO_BEGIN; |
- TESTCASE_AUTO(pluralFormatBasicTest); |
- TESTCASE_AUTO(pluralFormatUnitTest); |
- TESTCASE_AUTO(pluralFormatLocaleTest); |
- TESTCASE_AUTO(pluralFormatExtendedTest); |
- TESTCASE_AUTO(pluralFormatExtendedParseTest); |
- TESTCASE_AUTO(ordinalFormatTest); |
- TESTCASE_AUTO(TestDecimals); |
- TESTCASE_AUTO_END; |
-} |
- |
-/** |
- * 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; |
-} |
- |
-/** |
- * 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 locale data used in PluralFormat class. |
- */ |
-void |
-PluralFormatTest::pluralFormatLocaleTest(/*char *par*/) |
-{ |
- int8_t pluralResults[PLURAL_TEST_ARRAY_SIZE]; // 0: is for default |
- |
- // ======= Test DefaultRule |
- logln("Testing PluralRules with no rule."); |
- // for CLDR 24, here delete tr, |
- // add id lo ms th zh |
- const char* oneRuleLocales[8] = {"id", "ja", "ko", "lo", "ms", "th", "vi", "zh"}; |
- UnicodeString testPattern = UNICODE_STRING_SIMPLE("other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; // other |
- helperTestResults(oneRuleLocales, 8, testPattern, pluralResults); |
- |
- // ====== Test Singular1 locales. |
- logln("Testing singular1 locales."); |
- // for CLDR 24, here delete da de en et fi gl he it nl pt pt sv bn ca gu is mr pa sw ur zu |
- // add hu tr others |
- const char* singular1Locales[56] = {"af","asa","az","bem","bez","bg","brx","chr", |
- "ckb","dv","ee","el","eo","es","eu","fo","fur","fy","gsw","ha", |
- "haw","hu","jgo","ka","kk","kl","ks","ku","lb","ml","mn","nah", |
- "nb","ne","nn","no","nr","om","or","pap","ps","rm","rof","sn", |
- "so", "sq","ta","te","tk","tn","tr","ts","vo","wae","xh","xog"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; |
- pluralResults[1]= PFT_ONE; |
- pluralResults[2]= PFT_OTHER; |
- helperTestResults(singular1Locales, 56, testPattern, pluralResults); |
- |
- // ======== Test Singular01 locales. |
- logln("Testing singular1 locales."); |
- // for CLDR 24, here add hy |
- const char* singular01Locales[4] = {"ff","fr","hy","kab"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_ONE; |
- pluralResults[2]= PFT_OTHER; |
- helperTestResults(singular01Locales, 4, testPattern, pluralResults); |
- |
- // ======== Test ZeroSingular locales. |
- logln("Testing singular1 locales."); |
- const char* zeroSingularLocales[1] = {"lv"}; |
- testPattern = UNICODE_STRING_SIMPLE("zero{zero} one{one} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_ZERO; |
- pluralResults[1]= PFT_ONE; |
- for (int32_t i=2; i<20; ++i) { |
- pluralResults[i]= (i < 10)? PFT_OTHER: PFT_ZERO; |
- pluralResults[i*10] = PFT_ZERO; |
- pluralResults[i*10+1] = PFT_ONE; // note override after loop |
- pluralResults[i*10+2] = PFT_OTHER; // note override after loop |
- } |
- pluralResults[111]= PFT_ZERO; |
- pluralResults[112]= PFT_ZERO; |
- helperTestResults(zeroSingularLocales, 1, testPattern, pluralResults); |
- |
- // ======== Test singular dual locales. |
- logln("Testing singular1 locales."); |
- const char* singularDualLocales[1] = {"ga"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} two{two} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; |
- pluralResults[1]= PFT_ONE; |
- pluralResults[2]= PFT_TWO; |
- pluralResults[3]= PFT_OTHER; |
- helperTestResults(singularDualLocales, 1, testPattern, pluralResults); |
- |
- // ======== Test Singular Zero Some locales. |
- logln("Testing singular1 locales."); |
- const char* singularZeroSomeLocales[1] = {"ro"}; |
- testPattern = UNICODE_STRING_SIMPLE("few{few} one{one} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_FEW; |
- for (int32_t i=1; i<20; ++i) { |
- pluralResults[i] = PFT_FEW; // note override after loop |
- pluralResults[100+i] = PFT_FEW; |
- } |
- pluralResults[1]= PFT_ONE; |
- helperTestResults(singularZeroSomeLocales, 1, testPattern, pluralResults); |
- |
- // ======== Test Special 12/19. |
- logln("Testing special 12 and 19."); |
- const char* special12_19Locales[1] = {"lt"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; |
- pluralResults[1]= PFT_ONE; |
- for (int32_t i=2; i<20; ++i) { |
- pluralResults[i]= (i < 10)? PFT_FEW: PFT_OTHER; |
- pluralResults[i*10] = PFT_OTHER; |
- if (i==11) continue; |
- pluralResults[i*10+1] = PFT_ONE; |
- pluralResults[i*10+2] = PFT_FEW; |
- } |
- helperTestResults(special12_19Locales, 1, testPattern, pluralResults); |
- |
- // ======== Test Paucal Except 11 14. |
- logln("Testing Paucal Except 11 and 14, set A."); |
- const char* paucal01LocalesA[2] = {"hr","sr"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; |
- pluralResults[1]= PFT_ONE; |
- for (int32_t i=2; i<20; ++i) { |
- pluralResults[i]= (i < 5)? PFT_FEW: PFT_OTHER; |
- if (i==11) continue; |
- pluralResults[i*10+1] = PFT_ONE; |
- pluralResults[i*10+2] = PFT_FEW; |
- pluralResults[i*10+5] = PFT_OTHER; |
- pluralResults[i*10+6] = PFT_OTHER; |
- pluralResults[i*10+7] = PFT_OTHER; |
- pluralResults[i*10+8] = PFT_OTHER; |
- pluralResults[i*10+9] = PFT_OTHER; |
- } |
- helperTestResults(paucal01LocalesA, 2, testPattern, pluralResults); |
- |
- logln("Testing Paucal Except 11 and 14, set B."); |
- const char* paucal01LocalesB[1] = {"ru"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} many{many} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_MANY; |
- pluralResults[1]= PFT_ONE; |
- for (int32_t i=2; i<20; ++i) { |
- pluralResults[i]= (i < 5)? PFT_OTHER: PFT_MANY; |
- if (i==11) continue; |
- pluralResults[i*10] = PFT_MANY; |
- pluralResults[i*10+1] = PFT_ONE; |
- pluralResults[i*10+2] = PFT_OTHER; |
- pluralResults[i*10+5] = PFT_MANY; |
- pluralResults[i*10+6] = PFT_MANY; |
- pluralResults[i*10+7] = PFT_MANY; |
- pluralResults[i*10+8] = PFT_MANY; |
- pluralResults[i*10+9] = PFT_MANY; |
- } |
- helperTestResults(paucal01LocalesB, 1, testPattern, pluralResults); |
- |
- logln("Testing Paucal Except 11 and 14, set C."); |
- const char* paucal01LocalesC[1] = {"uk"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} many{many} few{few} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_MANY; |
- pluralResults[1]= PFT_ONE; |
- for (int32_t i=2; i<20; ++i) { |
- pluralResults[i]= (i < 5)? PFT_FEW: PFT_MANY; |
- if (i==11) continue; |
- pluralResults[i*10] = PFT_MANY; |
- pluralResults[i*10+1] = PFT_ONE; |
- pluralResults[i*10+2] = PFT_FEW; |
- pluralResults[i*10+5] = PFT_MANY; |
- pluralResults[i*10+6] = PFT_MANY; |
- pluralResults[i*10+7] = PFT_MANY; |
- pluralResults[i*10+8] = PFT_MANY; |
- pluralResults[i*10+9] = PFT_MANY; |
- } |
- helperTestResults(paucal01LocalesC, 1, testPattern, pluralResults); |
- |
- // ======== Test Singular Paucal. |
- logln("Testing Singular Paucal."); |
- const char* singularPaucalLocales[2] = {"cs","sk"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; |
- pluralResults[1]= PFT_ONE; |
- pluralResults[2]= PFT_FEW; |
- pluralResults[5]= PFT_OTHER; |
- helperTestResults(singularPaucalLocales, 2, testPattern, pluralResults); |
- |
- // ======== Test Paucal (1), (2,3,4). |
- logln("Testing Paucal (1), (2,3,4)."); |
- const char* paucal02Locales[1] = {"pl"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} many{many} few{few} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- for (int32_t i=0; i<20; ++i) { |
- pluralResults[i*10+0] = PFT_MANY; |
- pluralResults[i*10+1] = PFT_MANY; // note override after loop |
- if ((i==1)||(i==11)) { |
- pluralResults[i*10+2] = PFT_MANY; |
- pluralResults[i*10+3] = PFT_MANY; |
- pluralResults[i*10+4] = PFT_MANY; |
- } |
- else { |
- pluralResults[i*10+2] = PFT_FEW; |
- pluralResults[i*10+3] = PFT_FEW; |
- pluralResults[i*10+4] = PFT_FEW; |
- } |
- pluralResults[i*10+5] = PFT_MANY; |
- } |
- pluralResults[1]= PFT_ONE; |
- helperTestResults(paucal02Locales, 1, testPattern, pluralResults); |
- |
- // ======== Test Paucal (1), (2), (3,4). |
- logln("Testing Paucal (1), (2), (3,4)."); |
- const char* paucal03Locales[1] = {"sl"}; |
- testPattern = UNICODE_STRING_SIMPLE("one{one} two{two} few{few} other{other}"); |
- uprv_memset(pluralResults, -1, sizeof(pluralResults)); |
- pluralResults[0]= PFT_OTHER; |
- pluralResults[1]= PFT_ONE; |
- pluralResults[2]= PFT_TWO; |
- pluralResults[3]= PFT_FEW; |
- pluralResults[5]= PFT_OTHER; |
- pluralResults[101]= PFT_ONE; |
- pluralResults[102]= PFT_TWO; |
- pluralResults[103]= PFT_FEW; |
- pluralResults[105]= PFT_OTHER; |
- helperTestResults(paucal03Locales, 1, testPattern, pluralResults); |
- |
- // TODO: move this test to Unit Test after CLDR 1.6 is final and we support float |
- // ======= Test French "WITHIN rule |
- logln("Testing PluralRules with fr rule."); |
- testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}"); |
- Locale ulocale((const char *)"fr"); |
- UErrorCode status = U_ZERO_ERROR; |
- PluralFormat plFmt(ulocale, testPattern, status); |
- if (U_FAILURE(status)) { |
- dataerrln("Failed to apply pattern to fr locale - %s", u_errorName(status)); |
- } |
- else { |
- status = U_ZERO_ERROR; |
- UnicodeString plResult = plFmt.format(0.0, status); // retrun ONE |
- plResult = plFmt.format(0.5, status); // retrun ONE |
- plResult = plFmt.format(1.0, status); // retrun ONE |
- plResult = plFmt.format(1.9, status); // retrun ONE |
- plResult = plFmt.format(2.0, status); // retrun OTHER |
- } |
-} |
- |
-void |
-PluralFormatTest::pluralFormatExtendedTest(void) { |
- const char *targets[] = { |
- "There are no widgets.", |
- "There is one widget.", |
- "There is a bling widget and one other widget.", |
- "There is a bling widget and 2 other widgets.", |
- "There is a bling widget and 3 other widgets.", |
- "Widgets, five (5-1=4) there be.", |
- "There is a bling widget and 5 other widgets.", |
- "There is a bling widget and 6 other widgets.", |
- }; |
- |
- const char* fmt = |
- "offset:1.0 " |
- "=0 {There are no widgets.} " |
- "=1.0 {There is one widget.} " |
- "=5 {Widgets, five (5-1=#) there be.} " |
- "one {There is a bling widget and one other widget.} " |
- "other {There is a bling widget and # other widgets.}"; |
- |
- UErrorCode status = U_ZERO_ERROR; |
- UnicodeString fmtString(fmt, -1, US_INV); |
- PluralFormat pf(Locale::getEnglish(), fmtString, status); |
- MessageFormat mf(UNICODE_STRING_SIMPLE("{0,plural,").append(fmtString).append((UChar)0x7d /* '}' */), |
- Locale::getEnglish(), status); |
- Formattable args; |
- FieldPosition ignore; |
- if (U_FAILURE(status)) { |
- dataerrln("Failed to apply pattern - %s", u_errorName(status)); |
- return; |
- } |
- for (int32_t i = 0; i <= 7; ++i) { |
- UnicodeString result = pf.format(i, status); |
- if (U_FAILURE(status)) { |
- errln("PluralFormat.format(value %d) failed - %s", i, u_errorName(status)); |
- return; |
- } |
- UnicodeString expected(targets[i], -1, US_INV); |
- if (expected != result) { |
- UnicodeString message("PluralFormat.format(): Expected '", -1, US_INV); |
- message.append(expected); |
- message.append(UnicodeString("' but got '", -1, US_INV)); |
- message.append(result); |
- message.append("'", -1, US_INV); |
- errln(message); |
- } |
- args.setLong(i); |
- mf.format(&args, 1, result.remove(), ignore, status); |
- if (U_FAILURE(status)) { |
- errln("MessageFormat.format(value %d) failed - %s", i, u_errorName(status)); |
- return; |
- } |
- if (expected != result) { |
- UnicodeString message("MessageFormat.format(): Expected '", -1, US_INV); |
- message.append(expected); |
- message.append(UnicodeString("' but got '", -1, US_INV)); |
- message.append(result); |
- message.append("'", -1, US_INV); |
- errln(message); |
- } |
- } |
-} |
- |
-void |
-PluralFormatTest::pluralFormatExtendedParseTest(void) { |
- const char *failures[] = { |
- "offset:1..0 =0 {Foo}", |
- "offset:1.0 {Foo}", |
- "=0= {Foo}", |
- "=0 {Foo} =0.0 {Bar}", |
- " = {Foo}", |
- }; |
- int len = sizeof(failures)/sizeof(failures[0]); |
- |
- for (int i = 0; i < len; ++i) { |
- UErrorCode status = U_ZERO_ERROR; |
- UnicodeString fmt(failures[i], -1, US_INV); |
- PluralFormat pf(fmt, status); |
- if (U_SUCCESS(status)) { |
- errln("expected failure when parsing '" + fmt + "'"); |
- } |
- } |
-} |
- |
-void |
-PluralFormatTest::ordinalFormatTest(void) { |
- IcuTestErrorCode errorCode(*this, "ordinalFormatTest"); |
- UnicodeString pattern("one{#st file}two{#nd file}few{#rd file}other{#th file}"); |
- PluralFormat pf(Locale::getEnglish(), UPLURAL_TYPE_ORDINAL, pattern, errorCode); |
- if (errorCode.logDataIfFailureAndReset("PluralFormat(en, UPLURAL_TYPE_ORDINAL, pattern) failed")) { |
- return; |
- } |
- UnicodeString result = pf.format((int32_t)321, errorCode); |
- if (!errorCode.logIfFailureAndReset("PluralFormat.format(321) failed") && |
- result != UNICODE_STRING_SIMPLE("321st file")) { |
- errln(UnicodeString("PluralFormat.format(321) wrong result string: ") + result); |
- } |
- result = pf.format((int32_t)22, errorCode); |
- if (!errorCode.logIfFailureAndReset("PluralFormat.format(22) failed") && |
- result != UNICODE_STRING_SIMPLE("22nd file")) { |
- errln(UnicodeString("PluralFormat.format(22) wrong result string: ") + result); |
- } |
- result = pf.format((int32_t)3, errorCode); |
- if (!errorCode.logIfFailureAndReset("PluralFormat.format(3) failed") && |
- result != UNICODE_STRING_SIMPLE("3rd file")) { |
- errln(UnicodeString("PluralFormat.format(3) wrong result string: ") + result); |
- } |
- |
- // Code coverage: Use the other new-for-UPluralType constructor as well. |
- PluralFormat pf2(Locale::getEnglish(), UPLURAL_TYPE_ORDINAL, errorCode); |
- pf2.applyPattern(pattern, errorCode); |
- if (errorCode.logIfFailureAndReset("PluralFormat(en, UPLURAL_TYPE_ORDINAL, pattern) failed")) { |
- return; |
- } |
- result = pf2.format((int32_t)456, errorCode); |
- if (!errorCode.logIfFailureAndReset("PluralFormat.format(456) failed") && |
- result != UNICODE_STRING_SIMPLE("456th file")) { |
- errln(UnicodeString("PluralFormat.format(456) wrong result string: ") + result); |
- } |
- result = pf2.format((int32_t)111, errorCode); |
- if (!errorCode.logIfFailureAndReset("PluralFormat.format(111) failed") && |
- result != UNICODE_STRING_SIMPLE("111th file")) { |
- errln(UnicodeString("PluralFormat.format(111) wrong result string: ") + result); |
- } |
-} |
- |
-void |
-PluralFormatTest::TestDecimals() { |
- IcuTestErrorCode errorCode(*this, "TestDecimals"); |
- // Simple number replacement. |
- PluralFormat pf(Locale::getEnglish(), "one{one meter}other{# meters}", errorCode); |
- assertEquals("simple format(1)", "one meter", pf.format((int32_t)1, errorCode), TRUE); |
- assertEquals("simple format(1.5)", "1.5 meters", pf.format(1.5, errorCode), TRUE); |
- PluralFormat pf2(Locale::getEnglish(), |
- "offset:1 one{another meter}other{another # meters}", errorCode); |
- DecimalFormat df("0.0", new DecimalFormatSymbols(Locale::getEnglish(), errorCode), errorCode); |
- pf2.setNumberFormat(&df, errorCode); |
- assertEquals("offset-decimals format(1)", "another 0.0 meters", pf2.format((int32_t)1, errorCode), TRUE); |
- assertEquals("offset-decimals format(2)", "another 1.0 meters", pf2.format((int32_t)2, errorCode), TRUE); |
- assertEquals("offset-decimals format(2.5)", "another 1.5 meters", pf2.format(2.5, errorCode), TRUE); |
- errorCode.reset(); |
-} |
- |
-void |
-PluralFormatTest::numberFormatTest(PluralFormat* plFmt, |
- NumberFormat *numFmt, |
- int32_t start, |
- int32_t end, |
- UnicodeString *numOddAppendStr, |
- UnicodeString *numEvenAppendStr, |
- UBool overwrite, // overwrite the numberFormat.format result |
- UnicodeString *message) { |
- UErrorCode status = U_ZERO_ERROR; |
- |
- if ( (plFmt==NULL) || (numFmt==NULL) ) { |
- dataerrln("ERROR: Could not create PluralFormat or NumberFormat - exitting"); |
- return; |
- } |
- UnicodeString plResult, numResult ; |
- |
- for (int32_t i=start; i<= end; ++i ) { |
- numResult.remove(); |
- numResult = numFmt->format(i, numResult); |
- plResult = plFmt->format(i, status); |
- if ((numOddAppendStr!= NULL)&&(numEvenAppendStr!=NULL)) { |
- if (overwrite) { |
- if (i&1) { |
- numResult = *numOddAppendStr; |
- } |
- else { |
- numResult = *numEvenAppendStr; |
- } |
- } |
- else { // Append the string |
- if (i&1) { |
- numResult += *numOddAppendStr; |
- } |
- else{ |
- numResult += *numEvenAppendStr; |
- } |
- } |
- } |
- if ( (numResult!=plResult) || U_FAILURE(status) ) { |
- if ( message == NULL ) { |
- errln("ERROR: Unexpected plural format - got:"+plResult+ UnicodeString(" expecting:")+numResult); |
- } |
- else { |
- errln( *message+UnicodeString(" got:")+plResult+UnicodeString(" expecting:")+numResult); |
- } |
- } |
- } |
- return; |
-} |
- |
- |
-void |
-PluralFormatTest::helperTestResults(const char** localeArray, |
- int32_t capacityOfArray, |
- UnicodeString& testPattern, |
- int8_t *expResults) { |
- UErrorCode status; |
- UnicodeString plResult; |
- const UnicodeString PLKeywordLookups[6] = { |
- UNICODE_STRING_SIMPLE("zero"), |
- UNICODE_STRING_SIMPLE("one"), |
- UNICODE_STRING_SIMPLE("two"), |
- UNICODE_STRING_SIMPLE("few"), |
- UNICODE_STRING_SIMPLE("many"), |
- UNICODE_STRING_SIMPLE("other"), |
- }; |
- |
- for (int32_t i=0; i<capacityOfArray; ++i) { |
- const char *locale = localeArray[i]; |
- Locale ulocale((const char *)locale); |
- status = U_ZERO_ERROR; |
- PluralFormat plFmt(ulocale, testPattern, status); |
- if (U_FAILURE(status)) { |
- dataerrln("Failed to apply pattern to locale:"+UnicodeString(localeArray[i]) + " - " + u_errorName(status)); |
- continue; |
- } |
- for (int32_t n=0; n<PLURAL_TEST_ARRAY_SIZE; ++n) { |
- if (expResults[n]!=-1) { |
- status = U_ZERO_ERROR; |
- plResult = plFmt.format(n, status); |
- if (U_FAILURE(status)) { |
- errln("ERROR: Failed to format number in locale data tests with locale: "+ |
- UnicodeString(localeArray[i])); |
- } |
- if (plResult != PLKeywordLookups[expResults[n]]){ |
- plResult = plFmt.format(n, status); |
- errln("ERROR: Unexpected format result in locale: "+UnicodeString(localeArray[i])+ |
- UnicodeString(" for value: ")+n+ |
- UnicodeString(" got:")+plResult+ |
- UnicodeString(" expecting:")+ PLKeywordLookups[expResults[n]]); |
- } |
- } |
- } |
- } |
-} |
- |
-#endif /* #if !UCONFIG_NO_FORMATTING */ |