Home | History | Annotate | Download | only in intltest 
      1 /********************************************************************
      2  * Copyright (c) 2008-2010, International Business Machines Corporation and
      3  * others. All Rights Reserved.
      4  ********************************************************************/
      5 
      6 #include "unicode/utypes.h"
      7 
      8 #if !UCONFIG_NO_FORMATTING
      9 
     10 #include "unicode/tmunit.h"
     11 #include "unicode/tmutamt.h"
     12 #include "unicode/tmutfmt.h"
     13 #include "tufmtts.h"
     14 #include "unicode/ustring.h"
     15 
     16 //TODO: put as compilation flag
     17 //#define TUFMTTS_DEBUG 1
     18 
     19 #ifdef TUFMTTS_DEBUG
     20 #include <iostream>
     21 #endif
     22 
     23 void TimeUnitTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) {
     24     if (exec) logln("TestSuite TimeUnitTest");
     25     switch (index) {
     26         TESTCASE(0, testBasic);
     27         TESTCASE(1, testAPI);
     28         TESTCASE(2, testGreek);
     29         default: name = ""; break;
     30     }
     31 }
     32 
     33 /**
     34  * Test basic
     35  */
     36 void TimeUnitTest::testBasic() {
     37     const char* locales[] = {"en", "sl", "fr", "zh", "ar", "ru", "zh_Hant", "pa"};
     38     for ( unsigned int locIndex = 0;
     39           locIndex < sizeof(locales)/sizeof(locales[0]);
     40           ++locIndex ) {
     41         UErrorCode status = U_ZERO_ERROR;
     42         Locale loc(locales[locIndex]);
     43         TimeUnitFormat** formats = new TimeUnitFormat*[2];
     44         formats[TimeUnitFormat::kFull] = new TimeUnitFormat(loc, status);
     45         if (!assertSuccess("TimeUnitFormat(full)", status, TRUE)) return;
     46         formats[TimeUnitFormat::kAbbreviate] = new TimeUnitFormat(loc, TimeUnitFormat::kAbbreviate, status);
     47         if (!assertSuccess("TimeUnitFormat(short)", status)) return;
     48 #ifdef TUFMTTS_DEBUG
     49         std::cout << "locale: " << locales[locIndex] << "\n";
     50 #endif
     51         for (int style = TimeUnitFormat::kFull;
     52              style <= TimeUnitFormat::kAbbreviate;
     53              ++style) {
     54           for (TimeUnit::UTimeUnitFields j = TimeUnit::UTIMEUNIT_YEAR;
     55              j < TimeUnit::UTIMEUNIT_FIELD_COUNT;
     56              j = (TimeUnit::UTimeUnitFields)(j+1)) {
     57 #ifdef TUFMTTS_DEBUG
     58             std::cout << "time unit: " << j << "\n";
     59 #endif
     60             double tests[] = {0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 5, 10, 100, 101.35};
     61             for (unsigned int i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i) {
     62 #ifdef TUFMTTS_DEBUG
     63                 std::cout << "number: " << tests[i] << "\n";
     64 #endif
     65                 TimeUnitAmount* source = new TimeUnitAmount(tests[i], j, status);
     66                 if (!assertSuccess("TimeUnitAmount()", status)) return;
     67                 UnicodeString formatted;
     68                 Formattable formattable;
     69                 formattable.adoptObject(source);
     70                 formatted = ((Format*)formats[style])->format(formattable, formatted, status);
     71                 if (!assertSuccess("format()", status)) return;
     72 #ifdef TUFMTTS_DEBUG
     73                 char formatResult[1000];
     74                 formatted.extract(0, formatted.length(), formatResult, "UTF-8");
     75                 std::cout << "format result: " << formatResult << "\n";
     76 #endif
     77                 Formattable result;
     78                 ((Format*)formats[style])->parseObject(formatted, result, status);
     79                 if (!assertSuccess("parseObject()", status)) return;
     80                 if (result != formattable) {
     81                     dataerrln("No round trip: ");
     82                 }
     83                 // other style parsing
     84                 Formattable result_1;
     85                 ((Format*)formats[1-style])->parseObject(formatted, result_1, status);
     86                 if (!assertSuccess("parseObject()", status)) return;
     87                 if (result_1 != formattable) {
     88                     dataerrln("No round trip: ");
     89                 }
     90             }
     91           }
     92         }
     93         delete formats[TimeUnitFormat::kFull];
     94         delete formats[TimeUnitFormat::kAbbreviate];
     95         delete[] formats;
     96     }
     97 }
     98 
     99 
    100 void TimeUnitTest::testAPI() {
    101     //================= TimeUnit =================
    102     UErrorCode status = U_ZERO_ERROR;
    103 
    104     TimeUnit* tmunit = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_YEAR, status);
    105     if (!assertSuccess("TimeUnit::createInstance", status)) return;
    106 
    107     TimeUnit* another = (TimeUnit*)tmunit->clone();
    108     TimeUnit third(*tmunit);
    109     TimeUnit fourth = third;
    110 
    111     assertTrue("orig and clone are equal", (*tmunit == *another));
    112     assertTrue("copied and assigned are equal", (third == fourth));
    113 
    114     TimeUnit* tmunit_m = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_MONTH, status);
    115     assertTrue("year != month", (*tmunit != *tmunit_m));
    116 
    117     TimeUnit::UTimeUnitFields field = tmunit_m->getTimeUnitField();
    118     assertTrue("field of month time unit is month", (field == TimeUnit::UTIMEUNIT_MONTH));
    119 
    120     delete tmunit;
    121     delete another;
    122     delete tmunit_m;
    123     //
    124     //================= TimeUnitAmount =================
    125 
    126     Formattable formattable((int32_t)2);
    127     TimeUnitAmount tma_long(formattable, TimeUnit::UTIMEUNIT_DAY, status);
    128     if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
    129 
    130     formattable.setDouble(2);
    131     TimeUnitAmount tma_double(formattable, TimeUnit::UTIMEUNIT_DAY, status);
    132     if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
    133 
    134     formattable.setDouble(3);
    135     TimeUnitAmount tma_double_3(formattable, TimeUnit::UTIMEUNIT_DAY, status);
    136     if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
    137 
    138     TimeUnitAmount tma(2, TimeUnit::UTIMEUNIT_DAY, status);
    139     if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
    140 
    141     TimeUnitAmount tma_h(2, TimeUnit::UTIMEUNIT_HOUR, status);
    142     if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
    143 
    144     TimeUnitAmount second(tma);
    145     TimeUnitAmount third_tma = tma;
    146     TimeUnitAmount* fourth_tma = (TimeUnitAmount*)tma.clone();
    147 
    148     assertTrue("orig and copy are equal", (second == tma));
    149     assertTrue("clone and assigned are equal", (third_tma == *fourth_tma));
    150     assertTrue("different if number diff", (tma_double != tma_double_3));
    151     assertTrue("different if number type diff", (tma_double != tma_long));
    152     assertTrue("different if time unit diff", (tma != tma_h));
    153     assertTrue("same even different constructor", (tma_double == tma));
    154 
    155     assertTrue("getTimeUnitField", (tma.getTimeUnitField() == TimeUnit::UTIMEUNIT_DAY));
    156     delete fourth_tma;
    157     //
    158     //================= TimeUnitFormat =================
    159     //
    160     TimeUnitFormat* tmf_en = new TimeUnitFormat(Locale("en"), status);
    161     if (!assertSuccess("TimeUnitFormat(en...)", status, TRUE)) return;
    162     TimeUnitFormat tmf_fr(Locale("fr"), status);
    163     if (!assertSuccess("TimeUnitFormat(fr...)", status)) return;
    164 
    165     assertTrue("TimeUnitFormat: en and fr diff", (*tmf_en != tmf_fr));
    166 
    167     TimeUnitFormat tmf_assign = *tmf_en;
    168     assertTrue("TimeUnitFormat: orig and assign are equal", (*tmf_en == tmf_assign));
    169 
    170     TimeUnitFormat tmf_copy(tmf_fr);
    171     assertTrue("TimeUnitFormat: orig and copy are equal", (tmf_fr == tmf_copy));
    172 
    173     TimeUnitFormat* tmf_clone = (TimeUnitFormat*)tmf_en->clone();
    174     assertTrue("TimeUnitFormat: orig and clone are equal", (*tmf_en == *tmf_clone));
    175     delete tmf_clone;
    176 
    177     tmf_en->setLocale(Locale("fr"), status);
    178     if (!assertSuccess("setLocale(fr...)", status)) return;
    179 
    180     NumberFormat* numberFmt = NumberFormat::createInstance(
    181                                  Locale("fr"), status);
    182     if (!assertSuccess("NumberFormat::createInstance()", status)) return;
    183     tmf_en->setNumberFormat(*numberFmt, status);
    184     if (!assertSuccess("setNumberFormat(en...)", status)) return;
    185     assertTrue("TimeUnitFormat: setLocale", (*tmf_en == tmf_fr));
    186 
    187     delete tmf_en;
    188 
    189     TimeUnitFormat* en_long = new TimeUnitFormat(Locale("en"), TimeUnitFormat::kFull, status);
    190     if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
    191     delete en_long;
    192 
    193     TimeUnitFormat* en_short = new TimeUnitFormat(Locale("en"), TimeUnitFormat::kAbbreviate, status);
    194     if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
    195     delete en_short;
    196 
    197     TimeUnitFormat* format = new TimeUnitFormat(status);
    198     format->setLocale(Locale("zh"), status);
    199     format->setNumberFormat(*numberFmt, status);
    200     if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
    201     delete numberFmt;
    202     delete format;
    203 }
    204 
    205 /* @bug 7902
    206  * Tests for Greek Language.
    207  * This tests that requests for short unit names correctly fall back
    208  * to long unit names for a locale where the locale data does not
    209  * provide short unit names. As of CLDR 1.9, Greek is one such language.
    210  */
    211 void TimeUnitTest::testGreek() {
    212     UErrorCode status = U_ZERO_ERROR;
    213 
    214     const char* locales[] = {"el-GR", "el"};
    215     TimeUnit::UTimeUnitFields tunits[] = {TimeUnit::UTIMEUNIT_SECOND, TimeUnit::UTIMEUNIT_MINUTE, TimeUnit::UTIMEUNIT_HOUR, TimeUnit::UTIMEUNIT_DAY, TimeUnit::UTIMEUNIT_MONTH, TimeUnit::UTIMEUNIT_YEAR};
    216     TimeUnitFormat::EStyle styles[] = {TimeUnitFormat::kFull, TimeUnitFormat::kAbbreviate};
    217     const int numbers[] = {1, 7};
    218 
    219     const UChar oneSecond[] = {0x0031, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03bf, 0};
    220     const UChar oneMinute[] = {0x0031, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03cc, 0};
    221     const UChar oneHour[] = {0x0031, 0x0020, 0x03ce, 0x03c1, 0x03b1, 0};
    222     const UChar oneDay[] = {0x0031, 0x0020, 0x03b7, 0x03bc, 0x03ad, 0x03c1, 0x03b1, 0};
    223     const UChar oneMonth[] = {0x0031, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x03b1, 0x03c2, 0};
    224     const UChar oneYear[] = {0x0031, 0x0020, 0x03ad, 0x03c4, 0x03bf, 0x03c2, 0};
    225     const UChar sevenSeconds[] = {0x0037, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03b1, 0};
    226     const UChar sevenMinutes[] = {0x0037, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03ac, 0};
    227     const UChar sevenHours[] = {0x0037, 0x0020, 0x03ce, 0x03c1, 0x03b5, 0x03c2, 0};
    228     const UChar sevenDays[] = {0x0037, 0x0020, 0x03b7, 0x03bc, 0x03ad, 0x03c1, 0x03b5, 0x03c2, 0};
    229     const UChar sevenMonths[] = {0x0037, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x03b5, 0x3c2, 0};
    230     const UChar sevenYears[] = {0x0037, 0x0020, 0x03ad, 0x03c4, 0x03b7, 0};
    231 
    232     const UnicodeString oneSecondStr(oneSecond);
    233     const UnicodeString oneMinuteStr(oneMinute);
    234     const UnicodeString oneHourStr(oneHour);
    235     const UnicodeString oneDayStr(oneDay);
    236     const UnicodeString oneMonthStr(oneMonth);
    237     const UnicodeString oneYearStr(oneYear);
    238     const UnicodeString sevenSecondsStr(sevenSeconds);
    239     const UnicodeString sevenMinutesStr(sevenMinutes);
    240     const UnicodeString sevenHoursStr(sevenHours);
    241     const UnicodeString sevenDaysStr(sevenDays);
    242     const UnicodeString sevenMonthsStr(sevenMonths);
    243     const UnicodeString sevenYearsStr(sevenYears);
    244 
    245     const UnicodeString expected[] = {oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
    246                               oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
    247                               sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
    248                               sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
    249                               oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
    250                               oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
    251                               sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
    252                               sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr};
    253 
    254     int counter = 0;
    255     for ( unsigned int locIndex = 0;
    256         locIndex < sizeof(locales)/sizeof(locales[0]);
    257         ++locIndex ) {
    258 
    259         Locale l = Locale::createFromName(locales[locIndex]);
    260 
    261         for ( unsigned int numberIndex = 0;
    262             numberIndex < sizeof(numbers)/sizeof(int);
    263             ++numberIndex ) {
    264 
    265             for ( unsigned int styleIndex = 0;
    266                 styleIndex < sizeof(styles)/sizeof(styles[0]);
    267                 ++styleIndex ) {
    268 
    269                 for ( unsigned int unitIndex = 0;
    270                     unitIndex < sizeof(tunits)/sizeof(tunits[0]);
    271                     ++unitIndex ) {
    272 
    273                     TimeUnitAmount *tamt = new TimeUnitAmount(numbers[numberIndex], tunits[unitIndex], status);
    274                     if (U_FAILURE(status)) {
    275                         dataerrln("generating TimeUnitAmount Object failed.");
    276 #ifdef TUFMTTS_DEBUG
    277                         std::cout << "Failed to get TimeUnitAmount for " << tunits[unitIndex] << "\n";
    278 #endif
    279                         return;
    280                     }
    281 
    282                     TimeUnitFormat *tfmt = new TimeUnitFormat(l, styles[styleIndex], status);
    283                     if (U_FAILURE(status)) {
    284                         dataerrln("generating TimeUnitAmount Object failed.");
    285 #ifdef TUFMTTS_DEBUG
    286                        std::cout <<  "Failed to get TimeUnitFormat for " << locales[locIndex] << "\n";
    287 #endif
    288                        return;
    289                     }
    290 
    291                     Formattable fmt;
    292                     UnicodeString str;
    293 
    294                     fmt.adoptObject(tamt);
    295                     str = ((Format *)tfmt)->format(fmt, str, status);
    296                     if (!assertSuccess("formatting relative time failed", status)) {
    297                         delete tfmt;
    298 #ifdef TUFMTTS_DEBUG
    299                         std::cout <<  "Failed to format" << "\n";
    300 #endif
    301                         return;
    302                     }
    303 
    304 #ifdef TUFMTTS_DEBUG
    305                     char tmp[128];    //output
    306                     char tmp1[128];    //expected
    307                     int len = 0;
    308                     u_strToUTF8(tmp, 128, &len, str.getTerminatedBuffer(), str.length(), &status);
    309                     u_strToUTF8(tmp1, 128, &len, expected[counter].unescape().getTerminatedBuffer(), expected[counter].unescape().length(), &status);
    310                     std::cout <<  "Formatted string : " << tmp << " expected : " << tmp1 << "\n";
    311 #endif
    312                     if (!assertEquals("formatted time string is not expected, locale: " + UnicodeString(locales[locIndex]) + " style: " + (int)styles[styleIndex] + " units: " + (int)tunits[unitIndex], expected[counter], str)) {
    313                         delete tfmt;
    314                         str.remove();
    315                         return;
    316                     }
    317                     delete tfmt;
    318                     str.remove();
    319                     ++counter;
    320                 }
    321             }
    322         }
    323     }
    324 }
    325 
    326 #endif
    327