blob: a57b8531a0ba9595b15e414aad36cc9d8141d21a [file] [log] [blame]
/*
*******************************************************************************
* Copyright (C) 1996-2000, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/dev/test/format/RbnfTest.java,v $
* $Date: 2002/02/22 03:43:32 $
* $Revision: 1.9 $
*
*****************************************************************************************
*/
package com.ibm.icu.dev.test.format;
import com.ibm.icu.text.RuleBasedNumberFormat;
import com.ibm.icu.dev.test.TestFmwk;
import java.util.Locale;
import java.text.NumberFormat;
public class RbnfTest extends TestFmwk {
/**
* Puts a copyright in the .class file
*/
private static final String copyrightNotice
= "Copyright \u00a91997-1999 IBM Corp. All rights reserved.";
public static void main(String[] args) {
RbnfTest test = new RbnfTest();
try {
test.run(args);
}
catch (Throwable e) {
System.out.println("Entire test failed because of exception: "
+ e.toString());
e.printStackTrace();
}
}
public void TestUndefinedSpellout() {
Locale greek = new Locale("el", "", "");
RuleBasedNumberFormat[] formatters = {
new RuleBasedNumberFormat(greek, RuleBasedNumberFormat.SPELLOUT),
new RuleBasedNumberFormat(greek, RuleBasedNumberFormat.ORDINAL),
new RuleBasedNumberFormat(greek, RuleBasedNumberFormat.DURATION),
};
String[] data = {
"0",
"1",
"15",
"20",
"23",
"73",
"88",
"100",
"106",
"127",
"200",
"579",
"1,000",
"2,000",
"3,004",
"4,567",
"15,943",
"105,000",
"2,345,678",
"-36",
"-36.91215",
"234.56789"
};
NumberFormat decFormat = NumberFormat.getInstance(Locale.US);
for (int j = 0; j < formatters.length; ++j) {
com.ibm.icu.text.NumberFormat formatter = formatters[j];
logln("formatter[" + j + "]");
for (int i = 0; i < data.length; ++i) {
try {
String result = formatter.format(decFormat.parse(data[i]));
logln("[" + i + "] " + data[i] + " ==> " + result);
}
catch (Exception e) {
errln("formatter[" + j + "], data[" + i + "] " + data[i] + " threw exception " + e.getMessage());
}
}
}
}
/**
* Perform a simple spot check on the English spellout rules
*/
public void TestEnglishSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(Locale.US,
RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "1", "one" },
{ "15", "fifteen" },
{ "20", "twenty" },
{ "23", "twenty-three" },
{ "73", "seventy-three" },
{ "88", "eighty-eight" },
{ "100", "one hundred" },
{ "106", "one hundred and six" },
{ "127", "one hundred and twenty-seven" },
{ "200", "two hundred" },
{ "579", "five hundred and seventy-nine" },
{ "1,000", "one thousand" },
{ "2,000", "two thousand" },
{ "3,004", "three thousand and four" },
{ "4,567", "four thousand five hundred and sixty-seven" },
{ "15,943", "fifteen thousand nine hundred and forty-three" },
{ "2,345,678", "two million, three hundred and forty-five "
+ "thousand, six hundred and seventy-eight" },
{ "-36", "minus thirty-six" },
{ "234.567", "two hundred and thirty-four point five six seven" }
};
doTest(formatter, testData, true);
formatter.setLenientParseMode(true);
String[][] lpTestData = {
{ "FOurhundred thiRTY six", "436" },
// test spaces before fifty-7 causing lenient parse match of "fifty-" to " fifty"
// leaving "-7" for remaining parse, resulting in 2643 as the parse result.
{ "fifty-7", "57" },
{ " fifty-7", "57" },
{ " fifty-7", "57" },
{ "2 thousand six HUNDRED fifty-7", "2,657" },
{ "fifteen hundred and zero", "1,500" }
};
doLenientParseTest(formatter, lpTestData);
}
/**
* Perform a simple spot check on the English ordinal-abbreviation rules
*/
public void TestOrdinalAbbreviations() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(Locale.US,
RuleBasedNumberFormat.ORDINAL);
String[][] testData = {
{ "1", "1st" },
{ "2", "2nd" },
{ "3", "3rd" },
{ "4", "4th" },
{ "7", "7th" },
{ "10", "10th" },
{ "11", "11th" },
{ "13", "13th" },
{ "20", "20th" },
{ "21", "21st" },
{ "22", "22nd" },
{ "23", "23rd" },
{ "24", "24th" },
{ "33", "33rd" },
{ "102", "102nd" },
{ "312", "312th" },
{ "12,345", "12,345th" }
};
doTest(formatter, testData, false);
}
/**
* Perform a simple spot check on the duration-formatting rules
*/
public void TestDurations() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(Locale.US,
RuleBasedNumberFormat.DURATION);
String[][] testData = {
{ "3,600", "1:00:00" }, //move me and I fail
{ "0", "0 sec." },
{ "1", "1 sec." },
{ "24", "24 sec." },
{ "60", "1:00" },
{ "73", "1:13" },
{ "145", "2:25" },
{ "666", "11:06" },
// { "3,600", "1:00:00" },
{ "3,740", "1:02:20" },
{ "10,293", "2:51:33" }
};
doTest(formatter, testData, true);
formatter.setLenientParseMode(true);
String[][] lpTestData = {
{ "2-51-33", "10,293" }
};
doLenientParseTest(formatter, lpTestData);
}
/**
* Perform a simple spot check on the Spanish spellout rules
*/
public void TestSpanishSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(new Locale("es", "es",
""), RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "1", "uno" },
{ "6", "seis" },
{ "16", "diecis\u00e9is" },
{ "20", "veinte" },
{ "24", "veinticuatro" },
{ "26", "veintis\u00e9is" },
{ "73", "setenta y tres" },
{ "88", "ochenta y ocho" },
{ "100", "cien" },
{ "106", "ciento seis" },
{ "127", "ciento veintisiete" },
{ "200", "doscientos" },
{ "579", "quinientos setenta y nueve" },
{ "1,000", "mil" },
{ "2,000", "dos mil" },
{ "3,004", "tres mil cuatro" },
{ "4,567", "cuatro mil quinientos sesenta y siete" },
{ "15,943", "quince mil novecientos cuarenta y tres" },
{ "2,345,678", "dos mill\u00f3n trescientos cuarenta y cinco mil "
+ "seiscientos setenta y ocho"},
{ "-36", "menos treinta y seis" },
{ "234.567", "doscientos treinta y cuatro punto cinco seis siete" }
};
doTest(formatter, testData, true);
}
/**
* Perform a simple spot check on the French spellout rules
*/
public void TestFrenchSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(Locale.FRANCE,
RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "1", "un" },
{ "15", "quinze" },
{ "20", "vingt" },
{ "21", "vingt-et-un" },
{ "23", "vingt-trois" },
{ "62", "soixante-deux" },
{ "70", "soixante-dix" },
{ "71", "soixante et onze" },
{ "73", "soixante-treize" },
{ "80", "quatre-vingts" },
{ "88", "quatre-vingt-huit" },
{ "100", "cent" },
{ "106", "cent six" },
{ "127", "cent vingt-sept" },
{ "200", "deux cents" },
{ "579", "cinq cents soixante-dix-neuf" },
{ "1,000", "mille" },
{ "1,123", "onze cents vingt-trois" },
{ "1,594", "mille cinq cents quatre-vingt-quatorze" },
{ "2,000", "deux mille" },
{ "3,004", "trois mille quatre" },
{ "4,567", "quatre mille cinq cents soixante-sept" },
{ "15,943", "quinze mille neuf cents quarante-trois" },
{ "2,345,678", "deux million trois cents quarante-cinq mille "
+ "six cents soixante-dix-huit" },
{ "-36", "moins trente-six" },
{ "234.567", "deux cents trente-quatre virgule cinq six sept" }
};
doTest(formatter, testData, true);
formatter.setLenientParseMode(true);
String[][] lpTestData = {
{ "trente-un", "31" },
{ "un cents quatre vingt dix huit", "198" }
};
doLenientParseTest(formatter, lpTestData);
}
/**
* Perform a simple spot check on the Swiss French spellout rules
*/
public void TestSwissFrenchSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(new Locale("fr", "CH",
""), RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "1", "un" },
{ "15", "quinze" },
{ "20", "vingt" },
{ "21", "vingt-et-un" },
{ "23", "vingt-trois" },
{ "62", "soixante-deux" },
{ "70", "septante" },
{ "71", "septante-et-un" },
{ "73", "septante-trois" },
{ "80", "octante" },
{ "88", "octante-huit" },
{ "100", "cent" },
{ "106", "cent six" },
{ "127", "cent vingt-sept" },
{ "200", "deux cents" },
{ "579", "cinq cents septante-neuf" },
{ "1,000", "mille" },
{ "1,123", "onze cents vingt-trois" },
{ "1,594", "mille cinq cents nonante-quatre" },
{ "2,000", "deux mille" },
{ "3,004", "trois mille quatre" },
{ "4,567", "quatre mille cinq cents soixante-sept" },
{ "15,943", "quinze mille neuf cents quarante-trois" },
{ "2,345,678", "deux million trois cents quarante-cinq mille "
+ "six cents septante-huit" },
{ "-36", "moins trente-six" },
{ "234.567", "deux cents trente-quatre virgule cinq six sept" }
};
doTest(formatter, testData, true);
}
/**
* Perform a simple spot check on the Italian spellout rules
*/
public void TestItalianSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(Locale.ITALIAN,
RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "1", "uno" },
{ "15", "quindici" },
{ "20", "venti" },
{ "23", "ventitre" },
{ "73", "settantatre" },
{ "88", "ottantotto" },
{ "100", "cento" },
{ "106", "centosei" },
{ "108", "centotto" },
{ "127", "centoventisette" },
{ "181", "centottantuno" },
{ "200", "duecento" },
{ "579", "cinquecentosettantanove" },
{ "1,000", "mille" },
{ "2,000", "duemila" },
{ "3,004", "tremilaquattro" },
{ "4,567", "quattromilacinquecentosessantasette" },
{ "15,943", "quindicimilanovecentoquarantatre" },
{ "-36", "meno trentisei" },
{ "234.567", "duecentotrentiquattro virgola cinque sei sette" }
};
doTest(formatter, testData, true);
}
/**
* Perform a simple spot check on the German spellout rules
*/
public void TestGermanSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(Locale.GERMANY,
RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "1", "eins" },
{ "15", "f\u00fcnfzehn" },
{ "20", "zwanzig" },
{ "23", "dreiundzwanzig" },
{ "73", "dreiundsiebzig" },
{ "88", "achtundachtzig" },
{ "100", "hundert" },
{ "106", "hundertsechs" },
{ "127", "hundertsiebenundzwanzig" },
{ "200", "zweihundert" },
{ "579", "f\u00fcnfhundertneunundsiebzig" },
{ "1,000", "tausend" },
{ "2,000", "zweitausend" },
{ "3,004", "dreitausendvier" },
{ "4,567", "viertausendf\u00fcnfhundertsiebenundsechzig" },
{ "15,943", "f\u00fcnfzehntausendneunhundertdreiundvierzig" },
{ "2,345,678", "zwei Millionen dreihundertf\u00fcnfundvierzigtausend"
+ "sechshundertachtundsiebzig" }
};
doTest(formatter, testData, true);
formatter.setLenientParseMode(true);
String[][] lpTestData = {
{ "ein Tausend sechs Hundert fuenfunddreissig", "1,635" }
};
doLenientParseTest(formatter, lpTestData);
}
/**
* Perform a simple spot check on the German spellout rules
*/
public void TestThaiSpellout() {
RuleBasedNumberFormat formatter
= new RuleBasedNumberFormat(new Locale("th", "TH", ""),
RuleBasedNumberFormat.SPELLOUT);
String[][] testData = {
{ "0", "\u0e28\u0e39\u0e19\u0e22\u0e4c" },
{ "1", "\u0e2b\u0e19\u0e36\u0e48\u0e07" },
{ "10", "\u0e2a\u0e34\u0e1a" },
{ "11", "\u0e2a\u0e34\u0e1a\u0e40\u0e2d\u0e47\u0e14" },
{ "21", "\u0e22\u0e35\u0e48\u0e2a\u0e34\u0e1a\u0e40\u0e2d\u0e47\u0e14" },
{ "101", "\u0e2b\u0e19\u0e36\u0e48\u0e07\u0e23\u0e49\u0e2d\u0e22\u0e2b\u0e19\u0e36\u0e48\u0e07" },
{ "1.234", "\u0e2b\u0e19\u0e36\u0e48\u0e07\u0e08\u0e38\u0e14\u0e2a\u0e2d\u0e07\u0e2a\u0e32\u0e21\u0e2a\u0e35\u0e48" },
};
doTest(formatter, testData, true);
/*
formatter.setLenientParseMode(true);
String[][] lpTestData = {
{ "ein Tausend sechs Hundert fuenfunddreissig", "1,635" }
};
doLenientParseTest(formatter, lpTestData);
*/
}
public void TestSwedishSpellout()
{
Locale locale = new Locale("sv", "", "");
RuleBasedNumberFormat formatter = new RuleBasedNumberFormat(locale, RuleBasedNumberFormat.SPELLOUT);
String[][] testDataDefault = {
{ "101", "etthundra\u00aden" },
{ "123", "etthundra\u00adtjugotre" },
{ "1,001", "ettusen en" },
{ "1,100", "ettusen etthundra" },
{ "1,101", "ettusen etthundra\u00aden" },
{ "1,234", "ettusen tv\u00e5hundra\u00adtrettiofyra" },
{ "10,001", "tio\u00adtusen en" },
{ "11,000", "elva\u00adtusen" },
{ "12,000", "tolv\u00adtusen" },
{ "20,000", "tjugo\u00adtusen" },
{ "21,000", "tjugoen\u00adtusen" },
{ "21,001", "tjugoen\u00adtusen en" },
{ "200,000", "tv\u00e5hundra\u00adtusen" },
{ "201,000", "tv\u00e5hundra\u00aden\u00adtusen" },
{ "200,200", "tv\u00e5hundra\u00adtusen tv\u00e5hundra" },
{ "2,002,000", "tv\u00e5 miljoner tv\u00e5\u00adtusen" },
{ "12,345,678", "tolv miljoner trehundra\u00adfyrtiofem\u00adtusen sexhundra\u00adsjuttio\u00e5tta" },
{ "123,456.789", "etthundra\u00adtjugotre\u00adtusen fyrahundra\u00adfemtiosex komma sju \u00e5tta nio" },
{ "-12,345.678", "minus tolv\u00adtusen trehundra\u00adfyrtiofem komma sex sju \u00e5tta" }
};
logln("testing default rules");
doTest(formatter, testDataDefault, true);
String[][] testDataNeutrum = {
{ "101", "etthundra\u00adett" },
{ "1,001", "ettusen ett" },
{ "1,101", "ettusen etthundra\u00adett" },
{ "10,001", "tio\u00adtusen ett" },
{ "21,001", "tjugoen\u00adtusen ett" }
};
formatter.setDefaultRuleSet("%neutrum");
logln("testing neutrum rules");
doTest(formatter, testDataNeutrum, true);
String[][] testDataYear = {
{ "101", "etthundra\u00adett" },
{ "900", "niohundra" },
{ "1,001", "tiohundra\u00adett" },
{ "1,100", "elvahundra" },
{ "1,101", "elvahundra\u00adett" },
{ "1,234", "tolvhundra\u00adtrettiofyra" },
{ "2,001", "tjugohundra\u00adett" },
{ "10,001", "tio\u00adtusen ett" }
};
formatter.setDefaultRuleSet("%year");
logln("testing year rules");
doTest(formatter, testDataYear, true);
}
void doTest(RuleBasedNumberFormat formatter, String[][] testData,
boolean testParsing) {
NumberFormat decFmt = NumberFormat.getInstance(Locale.US);
try {
for (int i = 0; i < testData.length; i++) {
String number = testData[i][0];
String expectedWords = testData[i][1];
String actualWords = formatter.format(decFmt.parse(number));
if (!actualWords.equals(expectedWords)) {
errln("Spot check failed: for " + number + ", expected "
+ expectedWords + ", but got " +
actualWords);
}
else if (testParsing) {
String actualNumber = decFmt.format(formatter
.parse(actualWords));
if (!actualNumber.equals(number)) {
errln("Spot check failed: for " + actualWords +
", expected " + number + ", but got " +
actualNumber);
}
}
}
}
catch (Throwable e) {
errln("Test failed with exception: " + e.toString());
e.printStackTrace();
}
}
void doLenientParseTest(RuleBasedNumberFormat formatter,
String[][] testData) {
NumberFormat decFmt = NumberFormat.getInstance(Locale.US);
try {
for (int i = 0; i < testData.length; i++) {
String words = testData[i][0];
String expectedNumber = testData[i][1];
String actualNumber = decFmt.format(formatter.parse(words));
if (!actualNumber.equals(expectedNumber)) {
errln("Lenient-parse spot check failed: for "
+ words + ", expected " + expectedNumber
+ ", but got " + actualNumber);
}
}
}
catch (Throwable e) {
errln("Test failed with exception: " + e.toString());
e.printStackTrace();
}
}
}