[apple/icu.git] / icuSources / test / intltest / tufmtts.cpp

/********************************************************************
 * Copyright (c) 2008-2012, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/tmunit.h"
#include "unicode/tmutamt.h"
#include "unicode/tmutfmt.h"
#include "tufmtts.h"
#include "unicode/ustring.h"

//TODO: put as compilation flag
//#define TUFMTTS_DEBUG 1

#ifdef TUFMTTS_DEBUG
#include <iostream>
#endif

void TimeUnitTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) {
    if (exec) logln("TestSuite TimeUnitTest");
    switch (index) {
        TESTCASE(0, testBasic);
        TESTCASE(1, testAPI);
        TESTCASE(2, testGreekWithFallback);
        TESTCASE(3, testGreekWithSanitization);
        default: name = ""; break;
    }
}

/**
 * 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 (result != formattable) {
                    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 (result_1 != formattable) {
                    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));
    
    delete tmunit;
    delete another;
    delete tmunit_m;
    //
    //================= 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 oneMinute[] = {0x0031, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03cc, 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 oneYear[] = {0x0031, 0x0020, 0x03ad, 0x03c4, 0x03bf, 0x03c2, 0};
    const UChar sevenSeconds[] = {0x0037, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03b1, 0};
    const UChar sevenMinutes[] = {0x0037, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03ac, 0};
    const UChar sevenHours[] = {0x0037, 0x0020, 0x03ce, 0x03c1, 0x03b5, 0x03c2, 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 sevenYears[] = {0x0037, 0x0020, 0x03ad, 0x03c4, 0x03b7, 0};

    const UnicodeString oneSecondStr(oneSecond);
    const UnicodeString oneMinuteStr(oneMinute);
    const UnicodeString oneHourStr(oneHour);
    const UnicodeString oneDayStr(oneDay);
    const UnicodeString oneMonthStr(oneMonth);
    const UnicodeString oneYearStr(oneYear);
    const UnicodeString sevenSecondsStr(sevenSeconds);
    const UnicodeString sevenMinutesStr(sevenMinutes);
    const UnicodeString sevenHoursStr(sevenHours);
    const UnicodeString sevenDaysStr(sevenDays);
    const UnicodeString sevenMonthsStr(sevenMonths);
    const UnicodeString sevenYearsStr(sevenYears);

    const UnicodeString expected[] = {oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
                              oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
                              sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
                              sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
                              oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
                              oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
                              sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
                              sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr};

    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;
}


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