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

/***********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2011, 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 saveLocale;
                    Locale::setDefault(Locale::getEnglish(), status);
                    if(U_FAILURE(status)) {
                        errln("ERROR: Could not set default locale, test may not give correct results");
                    }
                    testAPI(/*par*/);
                    Locale::setDefault(saveLocale, status);
                }
                break;

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

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

        case 3: name = "TestCoverage";
                if (exec) {
                    logln("TestCoverage---"); logln("");
                    TestCoverage();
                }
                break;

        default: name = ""; break;
    }
}

/**
 * Add better code coverage.
 */
void IntlTestDateFormatAPI::TestCoverage(void)
{
    const char *LOCALES[] = {
            "zh_CN@calendar=chinese",
            "cop_EG@calendar=coptic",
            "hi_IN@calendar=indian",
            "am_ET@calendar=ethiopic"
    };
    int32_t numOfLocales = 4;

    for (int32_t i = 0; i < numOfLocales; i++) {
        DateFormat *df = DateFormat::createDateTimeInstance(DateFormat::kMedium, DateFormat::kMedium, Locale(LOCALES[i]));
        if (df == NULL){
            dataerrln("Error creating DateFormat instances.");
            return;
        }
        delete df;
    }
}
/**
 * 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 == NULL || b == NULL){
        dataerrln("Error calling DateFormat::createInstance()");
        delete a;
        delete b;
        return;
    }

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

    SimpleDateFormat *sdtfmt = dynamic_cast<SimpleDateFormat *>(b);
    if (sdtfmt != NULL)
    {
        double ONE_YEAR = 365*24*60*60*1000.0;
        sdtfmt->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());

    if (def == NULL || fr == NULL || it == NULL || de == NULL){
        dataerrln("Error creating DateFormat instances.");
    }

// ======= Test equality
if (fr != NULL && def != NULL)
{
    logln("Testing equality operator");
    
    if( *fr == *it ) {
        errln("ERROR: == failed");
    }
}

// ======= Test various format() methods
if (fr != NULL && it != NULL && de != NULL)
{
    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()
if (def != NULL)
{
    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
if (fr != NULL && it != NULL && de != NULL)
{
    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)) {
        dataerrln("ERROR: Couldn't create a DateFormat - %s", u_errorName(status));
    }

    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 {
            dataerrln("FAIL: Can't create DateFormat");
        }
    }

    // SimpleDateFormat calling Format & DateFormat API
    {
        logln("SimpleDateFormat");
        status = U_ZERO_ERROR;
        SimpleDateFormat sdf(status);
        if (U_SUCCESS(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);
            sdf.getNumberFormat();
        } else {
            dataerrln("FAIL: Can't create SimpleDateFormat() - %s", u_errorName(status));
        }
    }

    // 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 {
            dataerrln("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 {
          errcheckln(status, "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:
4388f060	3	* Copyright (c) 1997-2011, International Business Machines Corporation
374ca955 A	4	* and others. All Rights Reserved.
374ca955 A	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;
73c04bcf	32	Locale saveLocale;
b75a7d8f A	33	Locale::setDefault(Locale::getEnglish(), status);
	34	if(U_FAILURE(status)) {
	35	errln("ERROR: Could not set default locale, test may not give correct results");
	36	}
	37	testAPI(/par/);
73c04bcf	38	Locale::setDefault(saveLocale, status);
b75a7d8f A	39	}
	40	break;
	41
	42	case 1: name = "TestEquals";
	43	if (exec) {
	44	logln("TestEquals---"); logln("");
	45	TestEquals();
	46	}
	47	break;
	48
	49	case 2: name = "TestNameHiding";
	50	if (exec) {
	51	logln("TestNameHiding---"); logln("");
	52	TestNameHiding();
	53	}
	54	break;
	55
729e4ab9 A	56	case 3: name = "TestCoverage";
	57	if (exec) {
	58	logln("TestCoverage---"); logln("");
	59	TestCoverage();
	60	}
	61	break;
	62
b75a7d8f A	63	default: name = ""; break;
	64	}
	65	}
	66
729e4ab9 A	67	/**
	68	* Add better code coverage.
	69	*/
	70	void IntlTestDateFormatAPI::TestCoverage(void)
	71	{
	72	const char *LOCALES[] = {
	73	"zh_CN@calendar=chinese",
	74	"cop_EG@calendar=coptic",
	75	"hi_IN@calendar=indian",
	76	"am_ET@calendar=ethiopic"
	77	};
	78	int32_t numOfLocales = 4;
	79
	80	for (int32_t i = 0; i < numOfLocales; i++) {
	81	DateFormat *df = DateFormat::createDateTimeInstance(DateFormat::kMedium, DateFormat::kMedium, Locale(LOCALES[i]));
	82	if (df == NULL){
	83	dataerrln("Error creating DateFormat instances.");
	84	return;
	85	}
	86	delete df;
	87	}
	88	}
b75a7d8f A	89	/**
	90	* Test that the equals method works correctly.
	91	*/
	92	void IntlTestDateFormatAPI::TestEquals(void)
	93	{
	94	UErrorCode status = U_ZERO_ERROR;
	95	// Create two objects at different system times
	96	DateFormat *a = DateFormat::createInstance();
	97	UDate start = Calendar::getNow();
	98	while (Calendar::getNow() == start) ; // Wait for time to change
	99	DateFormat *b = DateFormat::createInstance();
	100
73c04bcf A	101	if (a == NULL \|\| b == NULL){
	102	dataerrln("Error calling DateFormat::createInstance()");
	103	delete a;
	104	delete b;
	105	return;
	106	}
	107
b75a7d8f A	108	if (!(a == b))
	109	errln("FAIL: DateFormat objects created at different times are unequal.");
	110
729e4ab9 A	111	SimpleDateFormat sdtfmt = dynamic_cast<SimpleDateFormat >(b);
729e4ab9 A	112	if (sdtfmt != NULL)
b75a7d8f A	113	{
b75a7d8f A	114	double ONE_YEAR = 3652460601000.0;
729e4ab9	115	sdtfmt->set2DigitYearStart(start + 50*ONE_YEAR, status);
b75a7d8f A	116	if (U_FAILURE(status))
	117	errln("FAIL: setTwoDigitStartDate failed.");
	118	else if (a == b)
	119	errln("FAIL: DateFormat objects with different two digit start dates are equal.");
	120	}
	121	delete a;
	122	delete b;
	123	}
	124
	125	/**
	126	* This test checks various generic API methods in DateFormat to achieve 100%
	127	* API coverage.
	128	*/
	129	void IntlTestDateFormatAPI::testAPI(/* char* par */)
	130	{
	131	UErrorCode status = U_ZERO_ERROR;
	132
	133	// ======= Test constructors
	134
	135	logln("Testing DateFormat constructors");
	136
	137	DateFormat *def = DateFormat::createInstance();
	138	DateFormat *fr = DateFormat::createTimeInstance(DateFormat::FULL, Locale::getFrench());
	139	DateFormat *it = DateFormat::createDateInstance(DateFormat::MEDIUM, Locale::getItalian());
	140	DateFormat *de = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG, Locale::getGerman());
	141
73c04bcf	142	if (def == NULL \|\| fr == NULL \|\| it == NULL \|\| de == NULL){
729e4ab9	143	dataerrln("Error creating DateFormat instances.");
73c04bcf	144	}
b75a7d8f	145
73c04bcf A	146	// ======= Test equality
	147	if (fr != NULL && def != NULL)
	148	{
b75a7d8f A	149	logln("Testing equality operator");
	150
	151	if( fr == it ) {
	152	errln("ERROR: == failed");
	153	}
73c04bcf	154	}
b75a7d8f A	155
b75a7d8f A	156	// ======= Test various format() methods
73c04bcf A	157	if (fr != NULL && it != NULL && de != NULL)
73c04bcf A	158	{
b75a7d8f A	159	logln("Testing various format() methods");
	160
	161	UDate d = 837039928046.0;
	162	Formattable fD(d, Formattable::kIsDate);
	163
	164	UnicodeString res1, res2, res3;
	165	FieldPosition pos1(0), pos2(0);
	166
	167	status = U_ZERO_ERROR;
	168	res1 = fr->format(d, res1, pos1, status);
	169	if(U_FAILURE(status)) {
	170	errln("ERROR: format() failed (French)");
	171	}
	172	logln( (UnicodeString) "" + d + " formatted to " + res1);
	173
	174	res2 = it->format(d, res2, pos2);
	175	logln( (UnicodeString) "" + d + " formatted to " + res2);
	176
	177	res3 = de->format(d, res3);
	178	logln( (UnicodeString) "" + d + " formatted to " + res3);
73c04bcf	179	}
b75a7d8f A	180
b75a7d8f A	181	// ======= Test parse()
73c04bcf A	182	if (def != NULL)
73c04bcf A	183	{
b75a7d8f A	184	logln("Testing parse()");
	185
	186	UnicodeString text("02/03/76 2:50 AM, CST");
	187	Formattable result1;
	188	UDate result2, result3;
	189	ParsePosition pos(0), pos01(0);
	190	def->parseObject(text, result1, pos);
	191	if(result1.getType() != Formattable::kDate) {
	192	errln("ERROR: parseObject() failed for " + text);
	193	}
	194	logln(text + " parsed into " + result1.getDate());
	195
	196	status = U_ZERO_ERROR;
	197	result2 = def->parse(text, status);
	198	if(U_FAILURE(status)) {
	199	errln("ERROR: parse() failed, stopping testing");
	200	return;
	201	}
	202	logln(text + " parsed into " + result2);
	203
	204	result3 = def->parse(text, pos01);
	205	logln(text + " parsed into " + result3);
73c04bcf	206	}
b75a7d8f A	207
b75a7d8f A	208	// ======= Test getters and setters
73c04bcf A	209	if (fr != NULL && it != NULL && de != NULL)
73c04bcf A	210	{
b75a7d8f A	211	logln("Testing getters and setters");
	212
	213	int32_t count = 0;
	214	const Locale *locales = DateFormat::getAvailableLocales(count);
	215	logln((UnicodeString) "Got " + count + " locales" );
	216	for(int32_t i = 0; i < count; i++) {
	217	UnicodeString name;
	218	name = locales[i].getName();
	219	logln(name);
	220	}
	221
	222	fr->setLenient(it->isLenient());
	223	if(fr->isLenient() != it->isLenient()) {
	224	errln("ERROR: setLenient() failed");
	225	}
	226
	227	const Calendar *cal = def->getCalendar();
	228	Calendar *newCal = cal->clone();
	229	de->adoptCalendar(newCal);
	230	it->setCalendar(*newCal);
	231	if( (de->getCalendar()) != (it->getCalendar())) {
	232	errln("ERROR: adopt or set Calendar() failed");
	233	}
	234
	235	const NumberFormat *nf = def->getNumberFormat();
	236	NumberFormat newNf = (NumberFormat) nf->clone();
	237	de->adoptNumberFormat(newNf);
	238	it->setNumberFormat(*newNf);
	239	if( (de->getNumberFormat()) != (it->getNumberFormat())) {
	240	errln("ERROR: adopt or set NumberFormat() failed");
	241	}
	242
	243	const TimeZone& tz = def->getTimeZone();
	244	TimeZone *newTz = tz.clone();
	245	de->adoptTimeZone(newTz);
	246	it->setTimeZone(*newTz);
	247	if( de->getTimeZone() != it->getTimeZone()) {
	248	errln("ERROR: adopt or set TimeZone() failed");
	249	}
73c04bcf	250	}
b75a7d8f A	251	// ======= Test getStaticClassID()
	252
	253	logln("Testing getStaticClassID()");
	254
	255	status = U_ZERO_ERROR;
	256	DateFormat *test = new SimpleDateFormat(status);
	257	if(U_FAILURE(status)) {
729e4ab9	258	dataerrln("ERROR: Couldn't create a DateFormat - %s", u_errorName(status));
b75a7d8f A	259	}
	260
	261	if(test->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
	262	errln("ERROR: getDynamicClassID() didn't return the expected value");
	263	}
	264
	265	delete test;
	266	delete def;
	267	delete fr;
	268	delete it;
	269	delete de;
	270	}
	271
	272	/**
	273	* Test hiding of parse() and format() APIs in the Format hierarchy.
	274	* We test the entire hierarchy, even though this test is located in
	275	* the DateFormat API test.
	276	*/
	277	void
	278	IntlTestDateFormatAPI::TestNameHiding(void) {
	279
	280	// N.B.: This test passes if it COMPILES, since it's a test of
	281	// compile-time name hiding.
	282
	283	UErrorCode status = U_ZERO_ERROR;
	284	Formattable dateObj(0, Formattable::kIsDate);
	285	Formattable numObj(3.1415926535897932384626433832795);
	286	Formattable obj;
	287	UnicodeString str;
	288	FieldPosition fpos;
	289	ParsePosition ppos;
	290
	291	// DateFormat calling Format API
	292	{
	293	logln("DateFormat");
	294	DateFormat *dateFmt = DateFormat::createInstance();
	295	if (dateFmt) {
	296	dateFmt->format(dateObj, str, status);
	297	dateFmt->format(dateObj, str, fpos, status);
	298	delete dateFmt;
	299	} else {
729e4ab9	300	dataerrln("FAIL: Can't create DateFormat");
b75a7d8f A	301	}
	302	}
	303
	304	// SimpleDateFormat calling Format & DateFormat API
	305	{
	306	logln("SimpleDateFormat");
	307	status = U_ZERO_ERROR;
	308	SimpleDateFormat sdf(status);
4388f060 A	309	if (U_SUCCESS(status)) {
	310	// Format API
	311	sdf.format(dateObj, str, status);
	312	sdf.format(dateObj, str, fpos, status);
	313	// DateFormat API
	314	sdf.format((UDate)0, str, fpos);
	315	sdf.format((UDate)0, str);
	316	sdf.parse(str, status);
	317	sdf.parse(str, ppos);
	318	sdf.getNumberFormat();
	319	} else {
	320	dataerrln("FAIL: Can't create SimpleDateFormat() - %s", u_errorName(status));
	321	}
b75a7d8f A	322	}
	323
	324	// NumberFormat calling Format API
	325	{
	326	logln("NumberFormat");
	327	status = U_ZERO_ERROR;
	328	NumberFormat *fmt = NumberFormat::createInstance(status);
	329	if (fmt) {
	330	fmt->format(numObj, str, status);
	331	fmt->format(numObj, str, fpos, status);
	332	delete fmt;
	333	} else {
729e4ab9	334	dataerrln("FAIL: Can't create NumberFormat()");
b75a7d8f A	335	}
	336	}
	337
	338	// DecimalFormat calling Format & NumberFormat API
	339	{
	340	logln("DecimalFormat");
	341	status = U_ZERO_ERROR;
	342	DecimalFormat fmt(status);
	343	if(U_SUCCESS(status)) {
	344	// Format API
	345	fmt.format(numObj, str, status);
	346	fmt.format(numObj, str, fpos, status);
	347	// NumberFormat API
	348	fmt.format(2.71828, str);
	349	fmt.format((int32_t)1234567, str);
	350	fmt.format(1.41421, str, fpos);
	351	fmt.format((int32_t)9876543, str, fpos);
	352	fmt.parse(str, obj, ppos);
	353	fmt.parse(str, obj, status);
	354	} else {
729e4ab9	355	errcheckln(status, "FAIL: Couldn't instantiate DecimalFormat, error %s. Quitting test", u_errorName(status));
b75a7d8f A	356	}
	357	}
	358
	359	// ChoiceFormat calling Format & NumberFormat API
	360	{
	361	logln("ChoiceFormat");
	362	status = U_ZERO_ERROR;
	363	ChoiceFormat fmt("0#foo\|1#foos\|2#foos", status);
	364	// Format API
	365	fmt.format(numObj, str, status);
	366	fmt.format(numObj, str, fpos, status);
	367	// NumberFormat API
	368	fmt.format(2.71828, str);
	369	fmt.format((int32_t)1234567, str);
	370	fmt.format(1.41421, str, fpos);
	371	fmt.format((int32_t)9876543, str, fpos);
	372	fmt.parse(str, obj, ppos);
	373	fmt.parse(str, obj, status);
	374	}
	375
	376	// MessageFormat calling Format API
	377	{
	378	logln("MessageFormat");
	379	status = U_ZERO_ERROR;
	380	MessageFormat fmt("", status);
	381	// Format API
	382	// We use dateObj, which MessageFormat should reject.
	383	// We're testing name hiding, not the format method.
	384	fmt.format(dateObj, str, status);
	385	fmt.format(dateObj, str, fpos, status);
	386	}
	387	}
	388
	389	#endif /* #if !UCONFIG_NO_FORMATTING */