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

/***********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2004, International Business Machines Corporation
 * and others. All Rights Reserved.
 ***********************************************************************/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "dtfmapts.h"

#include "unicode/datefmt.h"
#include "unicode/smpdtfmt.h"
#include "unicode/decimfmt.h"
#include "unicode/choicfmt.h"
#include "unicode/msgfmt.h"


// This is an API test, not a unit test.  It doesn't test very many cases, and doesn't
// try to test the full functionality.  It just calls each function in the class and
// verifies that it works on a basic level.

void IntlTestDateFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln("TestSuite DateFormatAPI");
    switch (index) {
        case 0: name = "DateFormat API test"; 
                if (exec) {
                    logln("DateFormat API test---"); logln("");
                    UErrorCode status = U_ZERO_ERROR;
                    Locale::setDefault(Locale::getEnglish(), status);
                    if(U_FAILURE(status)) {
                        errln("ERROR: Could not set default locale, test may not give correct results");
                    }
                    testAPI(/*par*/);
                }
                break;

        case 1: name = "TestEquals"; 
                if (exec) {
                    logln("TestEquals---"); logln("");
                    TestEquals();
                }
                break;

        case 2: name = "TestNameHiding"; 
                if (exec) {
                    logln("TestNameHiding---"); logln("");
                    TestNameHiding();
                }
                break;

        default: name = ""; break;
    }
}

/**
 * Test that the equals method works correctly.
 */
void IntlTestDateFormatAPI::TestEquals(void)
{
    UErrorCode status = U_ZERO_ERROR;
    // Create two objects at different system times
    DateFormat *a = DateFormat::createInstance();
    UDate start = Calendar::getNow();
    while (Calendar::getNow() == start) ; // Wait for time to change
    DateFormat *b = DateFormat::createInstance();

    if (!(*a == *b))
        errln("FAIL: DateFormat objects created at different times are unequal.");

    if (b->getDynamicClassID() == SimpleDateFormat::getStaticClassID())
    {
        double ONE_YEAR = 365*24*60*60*1000.0;
        ((SimpleDateFormat*)b)->set2DigitYearStart(start + 50*ONE_YEAR, status);
        if (U_FAILURE(status))
            errln("FAIL: setTwoDigitStartDate failed.");
        else if (*a == *b)
            errln("FAIL: DateFormat objects with different two digit start dates are equal.");
    }
    delete a;
    delete b;
}

/**
 * This test checks various generic API methods in DateFormat to achieve 100%
 * API coverage.
 */
void IntlTestDateFormatAPI::testAPI(/* char* par */)
{
    UErrorCode status = U_ZERO_ERROR;

// ======= Test constructors

    logln("Testing DateFormat constructors");

    DateFormat *def = DateFormat::createInstance();
    DateFormat *fr = DateFormat::createTimeInstance(DateFormat::FULL, Locale::getFrench());
    DateFormat *it = DateFormat::createDateInstance(DateFormat::MEDIUM, Locale::getItalian());
    DateFormat *de = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG, Locale::getGerman());

// ======= Test equality

    logln("Testing equality operator");
    
    if( *fr == *it ) {
        errln("ERROR: == failed");
    }

// ======= Test various format() methods

    logln("Testing various format() methods");

    UDate d = 837039928046.0;
    Formattable fD(d, Formattable::kIsDate);

    UnicodeString res1, res2, res3;
    FieldPosition pos1(0), pos2(0);
    
    status = U_ZERO_ERROR;
    res1 = fr->format(d, res1, pos1, status);
    if(U_FAILURE(status)) {
        errln("ERROR: format() failed (French)");
    }
    logln( (UnicodeString) "" + d + " formatted to " + res1);

    res2 = it->format(d, res2, pos2);
    logln( (UnicodeString) "" + d + " formatted to " + res2);

    res3 = de->format(d, res3);
    logln( (UnicodeString) "" + d + " formatted to " + res3);

// ======= Test parse()

    logln("Testing parse()");

    UnicodeString text("02/03/76 2:50 AM, CST");
    Formattable result1;
    UDate result2, result3;
    ParsePosition pos(0), pos01(0);
    def->parseObject(text, result1, pos);
    if(result1.getType() != Formattable::kDate) {
        errln("ERROR: parseObject() failed for " + text);
    }
    logln(text + " parsed into " + result1.getDate());

    status = U_ZERO_ERROR;
    result2 = def->parse(text, status);
    if(U_FAILURE(status)) {
        errln("ERROR: parse() failed, stopping testing");
        return;
    }
    logln(text + " parsed into " + result2);

    result3 = def->parse(text, pos01);
    logln(text + " parsed into " + result3);


// ======= Test getters and setters

    logln("Testing getters and setters");

    int32_t count = 0;
    const Locale *locales = DateFormat::getAvailableLocales(count);
    logln((UnicodeString) "Got " + count + " locales" );
    for(int32_t i = 0; i < count; i++) {
        UnicodeString name;
        name = locales[i].getName();
        logln(name);
    }

    fr->setLenient(it->isLenient());
    if(fr->isLenient() != it->isLenient()) {
        errln("ERROR: setLenient() failed");
    }

    const Calendar *cal = def->getCalendar();
    Calendar *newCal = cal->clone();
    de->adoptCalendar(newCal);  
    it->setCalendar(*newCal);
    if( *(de->getCalendar()) != *(it->getCalendar())) {
        errln("ERROR: adopt or set Calendar() failed");
    }

    const NumberFormat *nf = def->getNumberFormat();
    NumberFormat *newNf = (NumberFormat*) nf->clone();
    de->adoptNumberFormat(newNf);   
    it->setNumberFormat(*newNf);
    if( *(de->getNumberFormat()) != *(it->getNumberFormat())) {
        errln("ERROR: adopt or set NumberFormat() failed");
    }

    const TimeZone& tz = def->getTimeZone();
    TimeZone *newTz = tz.clone();
    de->adoptTimeZone(newTz);   
    it->setTimeZone(*newTz);
    if( de->getTimeZone() != it->getTimeZone()) {
        errln("ERROR: adopt or set TimeZone() failed");
    }

// ======= Test getStaticClassID()

    logln("Testing getStaticClassID()");

    status = U_ZERO_ERROR;
    DateFormat *test = new SimpleDateFormat(status);
    if(U_FAILURE(status)) {
        errln("ERROR: Couldn't create a DateFormat");
    }

    if(test->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
        errln("ERROR: getDynamicClassID() didn't return the expected value");
    }

    delete test;
    delete def;
    delete fr;
    delete it;
    delete de;
}

/**
 * Test hiding of parse() and format() APIs in the Format hierarchy.
 * We test the entire hierarchy, even though this test is located in
 * the DateFormat API test.
 */
void
IntlTestDateFormatAPI::TestNameHiding(void) {

    // N.B.: This test passes if it COMPILES, since it's a test of
    // compile-time name hiding.

    UErrorCode status = U_ZERO_ERROR;
    Formattable dateObj(0, Formattable::kIsDate);
    Formattable numObj(3.1415926535897932384626433832795);
    Formattable obj;
    UnicodeString str;
    FieldPosition fpos;
    ParsePosition ppos;

    // DateFormat calling Format API
    {
        logln("DateFormat");
        DateFormat *dateFmt = DateFormat::createInstance();
        if (dateFmt) {
            dateFmt->format(dateObj, str, status);
            dateFmt->format(dateObj, str, fpos, status);
            delete dateFmt;
        } else {
            errln("FAIL: Can't create DateFormat");
        }
    }

    // SimpleDateFormat calling Format & DateFormat API
    {
        logln("SimpleDateFormat");
        status = U_ZERO_ERROR;
        SimpleDateFormat sdf(status);
        // Format API
        sdf.format(dateObj, str, status);
        sdf.format(dateObj, str, fpos, status);
        // DateFormat API
        sdf.format((UDate)0, str, fpos);
        sdf.format((UDate)0, str);
        sdf.parse(str, status);
        sdf.parse(str, ppos);
    }

    // NumberFormat calling Format API
    {
        logln("NumberFormat");
        status = U_ZERO_ERROR;
        NumberFormat *fmt = NumberFormat::createInstance(status);
        if (fmt) {
            fmt->format(numObj, str, status);
            fmt->format(numObj, str, fpos, status);
            delete fmt;
        } else {
            errln("FAIL: Can't create NumberFormat()");
        }
    }

    // DecimalFormat calling Format & NumberFormat API
    {
        logln("DecimalFormat");
        status = U_ZERO_ERROR;
        DecimalFormat fmt(status);
        if(U_SUCCESS(status)) {
          // Format API
          fmt.format(numObj, str, status);
          fmt.format(numObj, str, fpos, status);
          // NumberFormat API
          fmt.format(2.71828, str);
          fmt.format((int32_t)1234567, str);
          fmt.format(1.41421, str, fpos);
          fmt.format((int32_t)9876543, str, fpos);
          fmt.parse(str, obj, ppos);
          fmt.parse(str, obj, status);
        } else {
          errln("FAIL: Couldn't instantiate DecimalFormat, error %s. Quitting test", u_errorName(status));
        }
    }

    // ChoiceFormat calling Format & NumberFormat API
    {
        logln("ChoiceFormat");
        status = U_ZERO_ERROR;
        ChoiceFormat fmt("0#foo|1#foos|2#foos", status);
        // Format API
        fmt.format(numObj, str, status);
        fmt.format(numObj, str, fpos, status);
        // NumberFormat API
        fmt.format(2.71828, str);
        fmt.format((int32_t)1234567, str);
        fmt.format(1.41421, str, fpos);
        fmt.format((int32_t)9876543, str, fpos);
        fmt.parse(str, obj, ppos);
        fmt.parse(str, obj, status);
    }

    // MessageFormat calling Format API
    {
        logln("MessageFormat");
        status = U_ZERO_ERROR;
        MessageFormat fmt("", status);
        // Format API
        // We use dateObj, which MessageFormat should reject.
        // We're testing name hiding, not the format method.
        fmt.format(dateObj, str, status);
        fmt.format(dateObj, str, fpos, status);
    }
}

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
374ca955	1	/***********************************************************************
b75a7d8f	2	* COPYRIGHT:
374ca955 A	3	* Copyright (c) 1997-2004, International Business Machines Corporation
	4	* and others. All Rights Reserved.
	5	***********************************************************************/
b75a7d8f A	6
	7	#include "unicode/utypes.h"
	8
	9	#if !UCONFIG_NO_FORMATTING
	10
	11	#include "dtfmapts.h"
	12
	13	#include "unicode/datefmt.h"
	14	#include "unicode/smpdtfmt.h"
	15	#include "unicode/decimfmt.h"
	16	#include "unicode/choicfmt.h"
	17	#include "unicode/msgfmt.h"
	18
	19
	20	// This is an API test, not a unit test. It doesn't test very many cases, and doesn't
	21	// try to test the full functionality. It just calls each function in the class and
	22	// verifies that it works on a basic level.
	23
	24	void IntlTestDateFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	25	{
	26	if (exec) logln("TestSuite DateFormatAPI");
	27	switch (index) {
	28	case 0: name = "DateFormat API test";
	29	if (exec) {
	30	logln("DateFormat API test---"); logln("");
	31	UErrorCode status = U_ZERO_ERROR;
	32	Locale::setDefault(Locale::getEnglish(), status);
	33	if(U_FAILURE(status)) {
	34	errln("ERROR: Could not set default locale, test may not give correct results");
	35	}
	36	testAPI(/par/);
	37	}
	38	break;
	39
	40	case 1: name = "TestEquals";
	41	if (exec) {
	42	logln("TestEquals---"); logln("");
	43	TestEquals();
	44	}
	45	break;
	46
	47	case 2: name = "TestNameHiding";
	48	if (exec) {
	49	logln("TestNameHiding---"); logln("");
	50	TestNameHiding();
	51	}
	52	break;
	53
	54	default: name = ""; break;
	55	}
	56	}
	57
	58	/**
	59	* Test that the equals method works correctly.
	60	*/
	61	void IntlTestDateFormatAPI::TestEquals(void)
	62	{
	63	UErrorCode status = U_ZERO_ERROR;
	64	// Create two objects at different system times
	65	DateFormat *a = DateFormat::createInstance();
	66	UDate start = Calendar::getNow();
	67	while (Calendar::getNow() == start) ; // Wait for time to change
	68	DateFormat *b = DateFormat::createInstance();
	69
70	if (!(a == b))
71	errln("FAIL: DateFormat objects created at different times are unequal.");
72
73	if (b->getDynamicClassID() == SimpleDateFormat::getStaticClassID())
74	{
75	double ONE_YEAR = 3652460601000.0;
76	((SimpleDateFormat)b)->set2DigitYearStart(start + 50ONE_YEAR, status);
77	if (U_FAILURE(status))
78	errln("FAIL: setTwoDigitStartDate failed.");
79	else if (a == b)
80	errln("FAIL: DateFormat objects with different two digit start dates are equal.");
81	}
82	delete a;
83	delete b;
84	}
85
86	/**
87	* This test checks various generic API methods in DateFormat to achieve 100%
88	* API coverage.
89	*/
90	void IntlTestDateFormatAPI::testAPI(/* char* par */)
91	{
92	UErrorCode status = U_ZERO_ERROR;
93
94	// ======= Test constructors
95
96	logln("Testing DateFormat constructors");
97
98	DateFormat *def = DateFormat::createInstance();
99	DateFormat *fr = DateFormat::createTimeInstance(DateFormat::FULL, Locale::getFrench());
100	DateFormat *it = DateFormat::createDateInstance(DateFormat::MEDIUM, Locale::getItalian());
101	DateFormat *de = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG, Locale::getGerman());
102
103	// ======= Test equality
104
105	logln("Testing equality operator");
106
107	if( fr == it ) {
108	errln("ERROR: == failed");
109	}
110
111	// ======= Test various format() methods
112
113	logln("Testing various format() methods");
114
115	UDate d = 837039928046.0;
116	Formattable fD(d, Formattable::kIsDate);
117
118	UnicodeString res1, res2, res3;
119	FieldPosition pos1(0), pos2(0);
120
121	status = U_ZERO_ERROR;
122	res1 = fr->format(d, res1, pos1, status);
123	if(U_FAILURE(status)) {
124	errln("ERROR: format() failed (French)");
125	}
126	logln( (UnicodeString) "" + d + " formatted to " + res1);
127
128	res2 = it->format(d, res2, pos2);
129	logln( (UnicodeString) "" + d + " formatted to " + res2);
130
131	res3 = de->format(d, res3);
132	logln( (UnicodeString) "" + d + " formatted to " + res3);
133
134	// ======= Test parse()
135
136	logln("Testing parse()");
137
138	UnicodeString text("02/03/76 2:50 AM, CST");
139	Formattable result1;
140	UDate result2, result3;
141	ParsePosition pos(0), pos01(0);
142	def->parseObject(text, result1, pos);
143	if(result1.getType() != Formattable::kDate) {
144	errln("ERROR: parseObject() failed for " + text);
145	}
146	logln(text + " parsed into " + result1.getDate());
147
148	status = U_ZERO_ERROR;
149	result2 = def->parse(text, status);
150	if(U_FAILURE(status)) {
151	errln("ERROR: parse() failed, stopping testing");
152	return;
153	}
154	logln(text + " parsed into " + result2);
155
156	result3 = def->parse(text, pos01);
157	logln(text + " parsed into " + result3);
158
159
160	// ======= Test getters and setters
161
162	logln("Testing getters and setters");
163
164	int32_t count = 0;
165	const Locale *locales = DateFormat::getAvailableLocales(count);
166	logln((UnicodeString) "Got " + count + " locales" );
167	for(int32_t i = 0; i < count; i++) {
168	UnicodeString name;
169	name = locales[i].getName();
170	logln(name);
171	}
172
173	fr->setLenient(it->isLenient());
174	if(fr->isLenient() != it->isLenient()) {
175	errln("ERROR: setLenient() failed");
176	}
177
178	const Calendar *cal = def->getCalendar();
179	Calendar *newCal = cal->clone();
180	de->adoptCalendar(newCal);
181	it->setCalendar(*newCal);
182	if( (de->getCalendar()) != (it->getCalendar())) {
183	errln("ERROR: adopt or set Calendar() failed");
184	}
185
186	const NumberFormat *nf = def->getNumberFormat();
187	NumberFormat newNf = (NumberFormat) nf->clone();
188	de->adoptNumberFormat(newNf);
189	it->setNumberFormat(*newNf);
190	if( (de->getNumberFormat()) != (it->getNumberFormat())) {
191	errln("ERROR: adopt or set NumberFormat() failed");
192	}
193
194	const TimeZone& tz = def->getTimeZone();
195	TimeZone *newTz = tz.clone();
196	de->adoptTimeZone(newTz);
197	it->setTimeZone(*newTz);
198	if( de->getTimeZone() != it->getTimeZone()) {
199	errln("ERROR: adopt or set TimeZone() failed");
200	}
201
202	// ======= Test getStaticClassID()
203
204	logln("Testing getStaticClassID()");
205
206	status = U_ZERO_ERROR;
207	DateFormat *test = new SimpleDateFormat(status);
208	if(U_FAILURE(status)) {
209	errln("ERROR: Couldn't create a DateFormat");
210	}
211
212	if(test->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
213	errln("ERROR: getDynamicClassID() didn't return the expected value");
214	}
215
216	delete test;
217	delete def;
218	delete fr;
219	delete it;
220	delete de;
221	}
222
223	/**
224	* Test hiding of parse() and format() APIs in the Format hierarchy.
225	* We test the entire hierarchy, even though this test is located in
226	* the DateFormat API test.
227	*/
228	void
229	IntlTestDateFormatAPI::TestNameHiding(void) {
230
231	// N.B.: This test passes if it COMPILES, since it's a test of
232	// compile-time name hiding.
233
234	UErrorCode status = U_ZERO_ERROR;
235	Formattable dateObj(0, Formattable::kIsDate);
236	Formattable numObj(3.1415926535897932384626433832795);
237	Formattable obj;
238	UnicodeString str;
239	FieldPosition fpos;
240	ParsePosition ppos;
241
242	// DateFormat calling Format API
243	{
244	logln("DateFormat");
245	DateFormat *dateFmt = DateFormat::createInstance();
246	if (dateFmt) {
247	dateFmt->format(dateObj, str, status);
248	dateFmt->format(dateObj, str, fpos, status);
249	delete dateFmt;
250	} else {
251	errln("FAIL: Can't create DateFormat");
252	}
253	}
254
255	// SimpleDateFormat calling Format & DateFormat API
256	{
257	logln("SimpleDateFormat");
258	status = U_ZERO_ERROR;
259	SimpleDateFormat sdf(status);
260	// Format API
261	sdf.format(dateObj, str, status);
262	sdf.format(dateObj, str, fpos, status);
263	// DateFormat API
264	sdf.format((UDate)0, str, fpos);
265	sdf.format((UDate)0, str);
266	sdf.parse(str, status);
267	sdf.parse(str, ppos);
268	}
269
270	// NumberFormat calling Format API
271	{
272	logln("NumberFormat");
273	status = U_ZERO_ERROR;
274	NumberFormat *fmt = NumberFormat::createInstance(status);
275	if (fmt) {
276	fmt->format(numObj, str, status);
277	fmt->format(numObj, str, fpos, status);
278	delete fmt;
279	} else {
374ca955	280	errln("FAIL: Can't create NumberFormat()");
b75a7d8f A	281	}
	282	}
	283
	284	// DecimalFormat calling Format & NumberFormat API
	285	{
	286	logln("DecimalFormat");
	287	status = U_ZERO_ERROR;
	288	DecimalFormat fmt(status);
	289	if(U_SUCCESS(status)) {
	290	// Format API
	291	fmt.format(numObj, str, status);
	292	fmt.format(numObj, str, fpos, status);
	293	// NumberFormat API
	294	fmt.format(2.71828, str);
	295	fmt.format((int32_t)1234567, str);
	296	fmt.format(1.41421, str, fpos);
	297	fmt.format((int32_t)9876543, str, fpos);
	298	fmt.parse(str, obj, ppos);
	299	fmt.parse(str, obj, status);
	300	} else {
	301	errln("FAIL: Couldn't instantiate DecimalFormat, error %s. Quitting test", u_errorName(status));
	302	}
	303	}
	304
	305	// ChoiceFormat calling Format & NumberFormat API
	306	{
	307	logln("ChoiceFormat");
	308	status = U_ZERO_ERROR;
	309	ChoiceFormat fmt("0#foo\|1#foos\|2#foos", status);
	310	// Format API
	311	fmt.format(numObj, str, status);
	312	fmt.format(numObj, str, fpos, status);
	313	// NumberFormat API
	314	fmt.format(2.71828, str);
	315	fmt.format((int32_t)1234567, str);
	316	fmt.format(1.41421, str, fpos);
	317	fmt.format((int32_t)9876543, str, fpos);
	318	fmt.parse(str, obj, ppos);
	319	fmt.parse(str, obj, status);
	320	}
	321
	322	// MessageFormat calling Format API
	323	{
	324	logln("MessageFormat");
	325	status = U_ZERO_ERROR;
	326	MessageFormat fmt("", status);
	327	// Format API
	328	// We use dateObj, which MessageFormat should reject.
	329	// We're testing name hiding, not the format method.
	330	fmt.format(dateObj, str, status);
	331	fmt.format(dateObj, str, fpos, status);
	332	}
	333	}
	334
	335	#endif /* #if !UCONFIG_NO_FORMATTING */