| Index: source/test/intltest/tufmtts.cpp
|
| diff --git a/source/test/intltest/tufmtts.cpp b/source/test/intltest/tufmtts.cpp
|
| deleted file mode 100644
|
| index 6b1ed5a0080f2878a43725ae3a12f3d3992164cf..0000000000000000000000000000000000000000
|
| --- a/source/test/intltest/tufmtts.cpp
|
| +++ /dev/null
|
| @@ -1,528 +0,0 @@
|
| -/********************************************************************
|
| - * Copyright (c) 2008-2015, International Business Machines Corporation and
|
| - * others. All Rights Reserved.
|
| - ********************************************************************/
|
| -
|
| -#include "unicode/utypes.h"
|
| -
|
| -#if !UCONFIG_NO_FORMATTING
|
| -
|
| -#include "unicode/decimfmt.h"
|
| -#include "unicode/tmunit.h"
|
| -#include "unicode/tmutamt.h"
|
| -#include "unicode/tmutfmt.h"
|
| -#include "unicode/ustring.h"
|
| -#include "cmemory.h"
|
| -#include "intltest.h"
|
| -
|
| -//TODO: put as compilation flag
|
| -//#define TUFMTTS_DEBUG 1
|
| -
|
| -#ifdef TUFMTTS_DEBUG
|
| -#include <iostream>
|
| -#endif
|
| -
|
| -class TimeUnitTest : public IntlTest {
|
| - void runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/ ) {
|
| - if (exec) logln("TestSuite TimeUnitTest");
|
| - TESTCASE_AUTO_BEGIN;
|
| - TESTCASE_AUTO(testBasic);
|
| - TESTCASE_AUTO(testAPI);
|
| - TESTCASE_AUTO(testGreekWithFallback);
|
| - TESTCASE_AUTO(testGreekWithSanitization);
|
| - TESTCASE_AUTO(test10219Plurals);
|
| - TESTCASE_AUTO(TestBritishShortHourFallback);
|
| - TESTCASE_AUTO_END;
|
| - }
|
| -
|
| -public:
|
| - /**
|
| - * Performs basic tests
|
| - **/
|
| - void testBasic();
|
| -
|
| - /**
|
| - * Performs API tests
|
| - **/
|
| - void testAPI();
|
| -
|
| - /**
|
| - * Performs tests for Greek
|
| - * This tests that requests for short unit names correctly fall back
|
| - * to long unit names for a locale where the locale data does not
|
| - * provide short unit names. As of CLDR 1.9, Greek is one such language.
|
| - **/
|
| - void testGreekWithFallback();
|
| -
|
| - /**
|
| - * Performs tests for Greek
|
| - * This tests that if the plural count listed in time unit format does not
|
| - * match those in the plural rules for the locale, those plural count in
|
| - * time unit format will be ingored and subsequently, fall back will kick in
|
| - * which is tested above.
|
| - * Without data sanitization, setNumberFormat() would crash.
|
| - * As of CLDR shiped in ICU4.8, Greek is one such language.
|
| - */
|
| - void testGreekWithSanitization();
|
| -
|
| - /**
|
| - * Performs unit test for ticket 10219 making sure that plurals work
|
| - * correctly with rounding.
|
| - */
|
| - void test10219Plurals();
|
| -
|
| - void TestBritishShortHourFallback();
|
| -};
|
| -
|
| -extern IntlTest *createTimeUnitTest() {
|
| - return new TimeUnitTest();
|
| -}
|
| -
|
| -// This function is more lenient than equals operator as it considers integer 3 hours and
|
| -// double 3.0 hours to be equal
|
| -static UBool tmaEqual(const TimeUnitAmount& left, const TimeUnitAmount& right) {
|
| - if (left.getTimeUnitField() != right.getTimeUnitField()) {
|
| - return FALSE;
|
| - }
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - if (!left.getNumber().isNumeric() || !right.getNumber().isNumeric()) {
|
| - return FALSE;
|
| - }
|
| - UBool result = left.getNumber().getDouble(status) == right.getNumber().getDouble(status);
|
| - if (U_FAILURE(status)) {
|
| - return FALSE;
|
| - }
|
| - return result;
|
| -}
|
| -
|
| -/**
|
| - * Test basic
|
| - */
|
| -void TimeUnitTest::testBasic() {
|
| - const char* locales[] = {"en", "sl", "fr", "zh", "ar", "ru", "zh_Hant", "pa"};
|
| - for ( unsigned int locIndex = 0;
|
| - locIndex < sizeof(locales)/sizeof(locales[0]);
|
| - ++locIndex ) {
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - Locale loc(locales[locIndex]);
|
| - TimeUnitFormat** formats = new TimeUnitFormat*[2];
|
| - formats[UTMUTFMT_FULL_STYLE] = new TimeUnitFormat(loc, status);
|
| - if (!assertSuccess("TimeUnitFormat(full)", status, TRUE)) return;
|
| - formats[UTMUTFMT_ABBREVIATED_STYLE] = new TimeUnitFormat(loc, UTMUTFMT_ABBREVIATED_STYLE, status);
|
| - if (!assertSuccess("TimeUnitFormat(short)", status)) return;
|
| -#ifdef TUFMTTS_DEBUG
|
| - std::cout << "locale: " << locales[locIndex] << "\n";
|
| -#endif
|
| - for (int style = UTMUTFMT_FULL_STYLE;
|
| - style <= UTMUTFMT_ABBREVIATED_STYLE;
|
| - ++style) {
|
| - for (TimeUnit::UTimeUnitFields j = TimeUnit::UTIMEUNIT_YEAR;
|
| - j < TimeUnit::UTIMEUNIT_FIELD_COUNT;
|
| - j = (TimeUnit::UTimeUnitFields)(j+1)) {
|
| -#ifdef TUFMTTS_DEBUG
|
| - std::cout << "time unit: " << j << "\n";
|
| -#endif
|
| - double tests[] = {0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 5, 10, 100, 101.35};
|
| - for (unsigned int i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i) {
|
| -#ifdef TUFMTTS_DEBUG
|
| - std::cout << "number: " << tests[i] << "\n";
|
| -#endif
|
| - TimeUnitAmount* source = new TimeUnitAmount(tests[i], j, status);
|
| - if (!assertSuccess("TimeUnitAmount()", status)) return;
|
| - UnicodeString formatted;
|
| - Formattable formattable;
|
| - formattable.adoptObject(source);
|
| - formatted = ((Format*)formats[style])->format(formattable, formatted, status);
|
| - if (!assertSuccess("format()", status)) return;
|
| -#ifdef TUFMTTS_DEBUG
|
| - char formatResult[1000];
|
| - formatted.extract(0, formatted.length(), formatResult, "UTF-8");
|
| - std::cout << "format result: " << formatResult << "\n";
|
| -#endif
|
| - Formattable result;
|
| - ((Format*)formats[style])->parseObject(formatted, result, status);
|
| - if (!assertSuccess("parseObject()", status)) return;
|
| - if (!tmaEqual(*((TimeUnitAmount *)result.getObject()), *((TimeUnitAmount *) formattable.getObject()))) {
|
| - dataerrln("No round trip: ");
|
| - }
|
| - // other style parsing
|
| - Formattable result_1;
|
| - ((Format*)formats[1-style])->parseObject(formatted, result_1, status);
|
| - if (!assertSuccess("parseObject()", status)) return;
|
| - if (!tmaEqual(*((TimeUnitAmount *)result_1.getObject()), *((TimeUnitAmount *) formattable.getObject()))) {
|
| - dataerrln("No round trip: ");
|
| - }
|
| - }
|
| - }
|
| - }
|
| - delete formats[UTMUTFMT_FULL_STYLE];
|
| - delete formats[UTMUTFMT_ABBREVIATED_STYLE];
|
| - delete[] formats;
|
| - }
|
| -}
|
| -
|
| -
|
| -void TimeUnitTest::testAPI() {
|
| - //================= TimeUnit =================
|
| - UErrorCode status = U_ZERO_ERROR;
|
| -
|
| - TimeUnit* tmunit = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_YEAR, status);
|
| - if (!assertSuccess("TimeUnit::createInstance", status)) return;
|
| -
|
| - TimeUnit* another = (TimeUnit*)tmunit->clone();
|
| - TimeUnit third(*tmunit);
|
| - TimeUnit fourth = third;
|
| -
|
| - assertTrue("orig and clone are equal", (*tmunit == *another));
|
| - assertTrue("copied and assigned are equal", (third == fourth));
|
| -
|
| - TimeUnit* tmunit_m = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_MONTH, status);
|
| - assertTrue("year != month", (*tmunit != *tmunit_m));
|
| -
|
| - TimeUnit::UTimeUnitFields field = tmunit_m->getTimeUnitField();
|
| - assertTrue("field of month time unit is month", (field == TimeUnit::UTIMEUNIT_MONTH));
|
| -
|
| - //===== Interoperability with MeasureUnit ======
|
| - MeasureUnit **ptrs = new MeasureUnit *[TimeUnit::UTIMEUNIT_FIELD_COUNT];
|
| -
|
| - ptrs[TimeUnit::UTIMEUNIT_YEAR] = MeasureUnit::createYear(status);
|
| - ptrs[TimeUnit::UTIMEUNIT_MONTH] = MeasureUnit::createMonth(status);
|
| - ptrs[TimeUnit::UTIMEUNIT_DAY] = MeasureUnit::createDay(status);
|
| - ptrs[TimeUnit::UTIMEUNIT_WEEK] = MeasureUnit::createWeek(status);
|
| - ptrs[TimeUnit::UTIMEUNIT_HOUR] = MeasureUnit::createHour(status);
|
| - ptrs[TimeUnit::UTIMEUNIT_MINUTE] = MeasureUnit::createMinute(status);
|
| - ptrs[TimeUnit::UTIMEUNIT_SECOND] = MeasureUnit::createSecond(status);
|
| - if (!assertSuccess("TimeUnit::createInstance", status)) return;
|
| -
|
| - for (TimeUnit::UTimeUnitFields j = TimeUnit::UTIMEUNIT_YEAR;
|
| - j < TimeUnit::UTIMEUNIT_FIELD_COUNT;
|
| - j = (TimeUnit::UTimeUnitFields)(j+1)) {
|
| - MeasureUnit *ptr = TimeUnit::createInstance(j, status);
|
| - if (!assertSuccess("TimeUnit::createInstance", status)) return;
|
| - // We have to convert *ptr to a MeasureUnit or else == will fail over
|
| - // differing types (TimeUnit vs. MeasureUnit).
|
| - assertTrue(
|
| - "Time unit should be equal to corresponding MeasureUnit",
|
| - MeasureUnit(*ptr) == *ptrs[j]);
|
| - delete ptr;
|
| - }
|
| - delete tmunit;
|
| - delete another;
|
| - delete tmunit_m;
|
| - for (int i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
|
| - delete ptrs[i];
|
| - }
|
| - delete [] ptrs;
|
| -
|
| - //
|
| - //================= TimeUnitAmount =================
|
| -
|
| - Formattable formattable((int32_t)2);
|
| - TimeUnitAmount tma_long(formattable, TimeUnit::UTIMEUNIT_DAY, status);
|
| - if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
|
| -
|
| - formattable.setDouble(2);
|
| - TimeUnitAmount tma_double(formattable, TimeUnit::UTIMEUNIT_DAY, status);
|
| - if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
|
| -
|
| - formattable.setDouble(3);
|
| - TimeUnitAmount tma_double_3(formattable, TimeUnit::UTIMEUNIT_DAY, status);
|
| - if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
|
| -
|
| - TimeUnitAmount tma(2, TimeUnit::UTIMEUNIT_DAY, status);
|
| - if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
|
| -
|
| - TimeUnitAmount tma_h(2, TimeUnit::UTIMEUNIT_HOUR, status);
|
| - if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
|
| -
|
| - TimeUnitAmount second(tma);
|
| - TimeUnitAmount third_tma = tma;
|
| - TimeUnitAmount* fourth_tma = (TimeUnitAmount*)tma.clone();
|
| -
|
| - assertTrue("orig and copy are equal", (second == tma));
|
| - assertTrue("clone and assigned are equal", (third_tma == *fourth_tma));
|
| - assertTrue("different if number diff", (tma_double != tma_double_3));
|
| - assertTrue("different if number type diff", (tma_double != tma_long));
|
| - assertTrue("different if time unit diff", (tma != tma_h));
|
| - assertTrue("same even different constructor", (tma_double == tma));
|
| -
|
| - assertTrue("getTimeUnitField", (tma.getTimeUnitField() == TimeUnit::UTIMEUNIT_DAY));
|
| - delete fourth_tma;
|
| - //
|
| - //================= TimeUnitFormat =================
|
| - //
|
| - TimeUnitFormat* tmf_en = new TimeUnitFormat(Locale("en"), status);
|
| - if (!assertSuccess("TimeUnitFormat(en...)", status, TRUE)) return;
|
| - TimeUnitFormat tmf_fr(Locale("fr"), status);
|
| - if (!assertSuccess("TimeUnitFormat(fr...)", status)) return;
|
| -
|
| - assertTrue("TimeUnitFormat: en and fr diff", (*tmf_en != tmf_fr));
|
| -
|
| - TimeUnitFormat tmf_assign = *tmf_en;
|
| - assertTrue("TimeUnitFormat: orig and assign are equal", (*tmf_en == tmf_assign));
|
| -
|
| - TimeUnitFormat tmf_copy(tmf_fr);
|
| - assertTrue("TimeUnitFormat: orig and copy are equal", (tmf_fr == tmf_copy));
|
| -
|
| - TimeUnitFormat* tmf_clone = (TimeUnitFormat*)tmf_en->clone();
|
| - assertTrue("TimeUnitFormat: orig and clone are equal", (*tmf_en == *tmf_clone));
|
| - delete tmf_clone;
|
| -
|
| - tmf_en->setLocale(Locale("fr"), status);
|
| - if (!assertSuccess("setLocale(fr...)", status)) return;
|
| -
|
| - NumberFormat* numberFmt = NumberFormat::createInstance(
|
| - Locale("fr"), status);
|
| - if (!assertSuccess("NumberFormat::createInstance()", status)) return;
|
| - tmf_en->setNumberFormat(*numberFmt, status);
|
| - if (!assertSuccess("setNumberFormat(en...)", status)) return;
|
| - assertTrue("TimeUnitFormat: setLocale", (*tmf_en == tmf_fr));
|
| -
|
| - delete tmf_en;
|
| -
|
| - TimeUnitFormat* en_long = new TimeUnitFormat(Locale("en"), UTMUTFMT_FULL_STYLE, status);
|
| - if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
|
| - delete en_long;
|
| -
|
| - TimeUnitFormat* en_short = new TimeUnitFormat(Locale("en"), UTMUTFMT_ABBREVIATED_STYLE, status);
|
| - if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
|
| - delete en_short;
|
| -
|
| - TimeUnitFormat* format = new TimeUnitFormat(status);
|
| - format->setLocale(Locale("zh"), status);
|
| - format->setNumberFormat(*numberFmt, status);
|
| - if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
|
| - delete numberFmt;
|
| - delete format;
|
| -}
|
| -
|
| -/* @bug 7902
|
| - * Tests for Greek Language.
|
| - * This tests that requests for short unit names correctly fall back
|
| - * to long unit names for a locale where the locale data does not
|
| - * provide short unit names. As of CLDR 1.9, Greek is one such language.
|
| - */
|
| -void TimeUnitTest::testGreekWithFallback() {
|
| - UErrorCode status = U_ZERO_ERROR;
|
| -
|
| - const char* locales[] = {"el-GR", "el"};
|
| - TimeUnit::UTimeUnitFields tunits[] = {TimeUnit::UTIMEUNIT_SECOND, TimeUnit::UTIMEUNIT_MINUTE, TimeUnit::UTIMEUNIT_HOUR, TimeUnit::UTIMEUNIT_DAY, TimeUnit::UTIMEUNIT_MONTH, TimeUnit::UTIMEUNIT_YEAR};
|
| - UTimeUnitFormatStyle styles[] = {UTMUTFMT_FULL_STYLE, UTMUTFMT_ABBREVIATED_STYLE};
|
| - const int numbers[] = {1, 7};
|
| -
|
| - const UChar oneSecond[] = {0x0031, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03bf, 0};
|
| - const UChar oneSecondShort[] = {0x0031, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x002e, 0};
|
| - const UChar oneMinute[] = {0x0031, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03cc, 0};
|
| - const UChar oneMinuteShort[] = {0x0031, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x002e, 0};
|
| - const UChar oneHour[] = {0x0031, 0x0020, 0x03ce, 0x03c1, 0x03b1, 0};
|
| - const UChar oneDay[] = {0x0031, 0x0020, 0x03b7, 0x03bc, 0x03ad, 0x03c1, 0x03b1, 0};
|
| - const UChar oneMonth[] = {0x0031, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x03b1, 0x03c2, 0};
|
| - const UChar oneMonthShort[] = {0x0031, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x002e, 0};
|
| - const UChar oneYear[] = {0x0031, 0x0020, 0x03ad, 0x03c4, 0x03bf, 0x03c2, 0};
|
| - const UChar oneYearShort[] = {0x0031, 0x0020, 0x03ad, 0x03c4, 0x002e, 0};
|
| - const UChar sevenSeconds[] = {0x0037, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03b1, 0};
|
| - const UChar sevenSecondsShort[] = {0x0037, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x002e, 0};
|
| - const UChar sevenMinutes[] = {0x0037, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03ac, 0};
|
| - const UChar sevenMinutesShort[] = {0x0037, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x002e, 0};
|
| - const UChar sevenHours[] = {0x0037, 0x0020, 0x03ce, 0x03c1, 0x03b5, 0x03c2, 0};
|
| - const UChar sevenHoursShort[] = {0x0037, 0x0020, 0x03ce, 0x03c1, 0x002e, 0};
|
| - const UChar sevenDays[] = {0x0037, 0x0020, 0x03b7, 0x03bc, 0x03ad, 0x03c1, 0x03b5, 0x03c2, 0};
|
| - const UChar sevenMonths[] = {0x0037, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x03b5, 0x3c2, 0};
|
| - const UChar sevenMonthsShort[] = {0x0037, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x002e, 0};
|
| - const UChar sevenYears[] = {0x0037, 0x0020, 0x03ad, 0x03c4, 0x03b7, 0};
|
| - const UChar sevenYearsShort[] = {0x0037, 0x0020, 0x03ad, 0x03c4, 0x002e, 0};
|
| -
|
| - const UnicodeString oneSecondStr(oneSecond);
|
| - const UnicodeString oneSecondShortStr(oneSecondShort);
|
| - const UnicodeString oneMinuteStr(oneMinute);
|
| - const UnicodeString oneMinuteShortStr(oneMinuteShort);
|
| - const UnicodeString oneHourStr(oneHour);
|
| - const UnicodeString oneDayStr(oneDay);
|
| - const UnicodeString oneMonthStr(oneMonth);
|
| - const UnicodeString oneMonthShortStr(oneMonthShort);
|
| - const UnicodeString oneYearStr(oneYear);
|
| - const UnicodeString oneYearShortStr(oneYearShort);
|
| - const UnicodeString sevenSecondsStr(sevenSeconds);
|
| - const UnicodeString sevenSecondsShortStr(sevenSecondsShort);
|
| - const UnicodeString sevenMinutesStr(sevenMinutes);
|
| - const UnicodeString sevenMinutesShortStr(sevenMinutesShort);
|
| - const UnicodeString sevenHoursStr(sevenHours);
|
| - const UnicodeString sevenHoursShortStr(sevenHoursShort);
|
| - const UnicodeString sevenDaysStr(sevenDays);
|
| - const UnicodeString sevenMonthsStr(sevenMonths);
|
| - const UnicodeString sevenMonthsShortStr(sevenMonthsShort);
|
| - const UnicodeString sevenYearsStr(sevenYears);
|
| - const UnicodeString sevenYearsShortStr(sevenYearsShort);
|
| -
|
| - const UnicodeString expected[] = {
|
| - oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
|
| - oneSecondShortStr, oneMinuteShortStr, oneHourStr, oneDayStr, oneMonthShortStr, oneYearShortStr,
|
| - sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
|
| - sevenSecondsShortStr, sevenMinutesShortStr, sevenHoursShortStr, sevenDaysStr, sevenMonthsShortStr, sevenYearsShortStr,
|
| -
|
| - oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
|
| - oneSecondShortStr, oneMinuteShortStr, oneHourStr, oneDayStr, oneMonthShortStr, oneYearShortStr,
|
| - sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
|
| - sevenSecondsShortStr, sevenMinutesShortStr, sevenHoursShortStr, sevenDaysStr, sevenMonthsShortStr, sevenYearsShortStr};
|
| -
|
| - int counter = 0;
|
| - for ( unsigned int locIndex = 0;
|
| - locIndex < sizeof(locales)/sizeof(locales[0]);
|
| - ++locIndex ) {
|
| -
|
| - Locale l = Locale::createFromName(locales[locIndex]);
|
| -
|
| - for ( unsigned int numberIndex = 0;
|
| - numberIndex < sizeof(numbers)/sizeof(int);
|
| - ++numberIndex ) {
|
| -
|
| - for ( unsigned int styleIndex = 0;
|
| - styleIndex < sizeof(styles)/sizeof(styles[0]);
|
| - ++styleIndex ) {
|
| -
|
| - for ( unsigned int unitIndex = 0;
|
| - unitIndex < sizeof(tunits)/sizeof(tunits[0]);
|
| - ++unitIndex ) {
|
| -
|
| - TimeUnitAmount *tamt = new TimeUnitAmount(numbers[numberIndex], tunits[unitIndex], status);
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("generating TimeUnitAmount Object failed.");
|
| -#ifdef TUFMTTS_DEBUG
|
| - std::cout << "Failed to get TimeUnitAmount for " << tunits[unitIndex] << "\n";
|
| -#endif
|
| - return;
|
| - }
|
| -
|
| - TimeUnitFormat *tfmt = new TimeUnitFormat(l, styles[styleIndex], status);
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("generating TimeUnitAmount Object failed.");
|
| -#ifdef TUFMTTS_DEBUG
|
| - std::cout << "Failed to get TimeUnitFormat for " << locales[locIndex] << "\n";
|
| -#endif
|
| - return;
|
| - }
|
| -
|
| - Formattable fmt;
|
| - UnicodeString str;
|
| -
|
| - fmt.adoptObject(tamt);
|
| - str = ((Format *)tfmt)->format(fmt, str, status);
|
| - if (!assertSuccess("formatting relative time failed", status)) {
|
| - delete tfmt;
|
| -#ifdef TUFMTTS_DEBUG
|
| - std::cout << "Failed to format" << "\n";
|
| -#endif
|
| - return;
|
| - }
|
| -
|
| -#ifdef TUFMTTS_DEBUG
|
| - char tmp[128]; //output
|
| - char tmp1[128]; //expected
|
| - int len = 0;
|
| - u_strToUTF8(tmp, 128, &len, str.getTerminatedBuffer(), str.length(), &status);
|
| - u_strToUTF8(tmp1, 128, &len, expected[counter].unescape().getTerminatedBuffer(), expected[counter].unescape().length(), &status);
|
| - std::cout << "Formatted string : " << tmp << " expected : " << tmp1 << "\n";
|
| -#endif
|
| - if (!assertEquals("formatted time string is not expected, locale: " + UnicodeString(locales[locIndex]) + " style: " + (int)styles[styleIndex] + " units: " + (int)tunits[unitIndex], expected[counter], str)) {
|
| - delete tfmt;
|
| - str.remove();
|
| - return;
|
| - }
|
| - delete tfmt;
|
| - str.remove();
|
| - ++counter;
|
| - }
|
| - }
|
| - }
|
| - }
|
| -}
|
| -
|
| -// Test bug9042
|
| -void TimeUnitTest::testGreekWithSanitization() {
|
| -
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - Locale elLoc("el");
|
| - NumberFormat* numberFmt = NumberFormat::createInstance(Locale("el"), status);
|
| - if (!assertSuccess("NumberFormat::createInstance for el locale", status, TRUE)) return;
|
| - numberFmt->setMaximumFractionDigits(1);
|
| -
|
| - TimeUnitFormat* timeUnitFormat = new TimeUnitFormat(elLoc, status);
|
| - if (!assertSuccess("TimeUnitFormat::TimeUnitFormat for el locale", status)) return;
|
| -
|
| - timeUnitFormat->setNumberFormat(*numberFmt, status);
|
| -
|
| - delete numberFmt;
|
| - delete timeUnitFormat;
|
| -}
|
| -
|
| -void TimeUnitTest::test10219Plurals() {
|
| - Locale usLocale("en_US");
|
| - double values[2] = {1.588, 1.011};
|
| - UnicodeString expected[2][3] = {
|
| - {"1 minute", "1.5 minutes", "1.58 minutes"},
|
| - {"1 minute", "1.0 minutes", "1.01 minutes"}
|
| - };
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - TimeUnitFormat tuf(usLocale, status);
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("generating TimeUnitFormat Object failed: %s", u_errorName(status));
|
| - return;
|
| - }
|
| - LocalPointer<DecimalFormat> nf((DecimalFormat *) NumberFormat::createInstance(usLocale, status));
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("generating NumberFormat Object failed: %s", u_errorName(status));
|
| - return;
|
| - }
|
| - for (int32_t j = 0; j < UPRV_LENGTHOF(values); ++j) {
|
| - for (int32_t i = 0; i < UPRV_LENGTHOF(expected[j]); ++i) {
|
| - nf->setMinimumFractionDigits(i);
|
| - nf->setMaximumFractionDigits(i);
|
| - nf->setRoundingMode(DecimalFormat::kRoundDown);
|
| - tuf.setNumberFormat(*nf, status);
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("setting NumberFormat failed: %s", u_errorName(status));
|
| - return;
|
| - }
|
| - UnicodeString actual;
|
| - Formattable fmt;
|
| - LocalPointer<TimeUnitAmount> tamt(
|
| - new TimeUnitAmount(values[j], TimeUnit::UTIMEUNIT_MINUTE, status), status);
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("generating TimeUnitAmount Object failed: %s", u_errorName(status));
|
| - return;
|
| - }
|
| - fmt.adoptObject(tamt.orphan());
|
| - tuf.format(fmt, actual, status);
|
| - if (U_FAILURE(status)) {
|
| - dataerrln("Actual formatting failed: %s", u_errorName(status));
|
| - return;
|
| - }
|
| - if (expected[j][i] != actual) {
|
| - errln("Expected " + expected[j][i] + ", got " + actual);
|
| - }
|
| - }
|
| - }
|
| -
|
| - // test parsing
|
| - Formattable result;
|
| - ParsePosition pos;
|
| - UnicodeString formattedString = "1 minutes";
|
| - tuf.parseObject(formattedString, result, pos);
|
| - if (formattedString.length() != pos.getIndex()) {
|
| - errln("Expect parsing to go all the way to the end of the string.");
|
| - }
|
| -}
|
| -
|
| -void TimeUnitTest::TestBritishShortHourFallback() {
|
| - // See ticket #11986 "incomplete fallback in MeasureFormat".
|
| - UErrorCode status = U_ZERO_ERROR;
|
| - Formattable oneHour(new TimeUnitAmount(1, TimeUnit::UTIMEUNIT_HOUR, status));
|
| - Locale en_GB("en_GB");
|
| - TimeUnitFormat formatter(en_GB, UTMUTFMT_ABBREVIATED_STYLE, status);
|
| - UnicodeString result;
|
| - formatter.format(oneHour, result, status);
|
| - assertSuccess("TestBritishShortHourFallback()", status);
|
| - assertEquals("TestBritishShortHourFallback()", UNICODE_STRING_SIMPLE("1 hr"), result);
|
| -}
|
| -
|
| -#endif
|
|
|
Chromium Code Reviews