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


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

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "intltest.h"
#include "tfsmalls.h"

#include "unicode/msgfmt.h"
#include "unicode/choicfmt.h"

#include "unicode/parsepos.h"
#include "unicode/fieldpos.h"
#include "unicode/fmtable.h"

#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))

/*static UBool chkstatus( UErrorCode &status, char* msg = NULL )
{
    UBool ok = (status == U_ZERO_ERROR);
    if (!ok) it_errln( msg );
    return ok;
}*/

void test_ParsePosition( void )
{
    ParsePosition* pp1 = new ParsePosition();
    if (pp1 && (pp1->getIndex() == 0)) {
        it_logln("PP constructor() tested.");
    }else{
        it_errln("*** PP getIndex or constructor() result");
    }
    delete pp1;


    {
        int32_t to = 5;
        ParsePosition pp2( to );
        if (pp2.getIndex() == 5) {
            it_logln("PP getIndex and constructor(int32_t) tested.");
        }else{
            it_errln("*** PP getIndex or constructor(int32_t) result");
        }
        pp2.setIndex( 3 );
        if (pp2.getIndex() == 3) {
            it_logln("PP setIndex tested.");
        }else{
            it_errln("*** PP getIndex or setIndex result");
        }
    }

    ParsePosition pp2, pp3;
    pp2 = 3;
    pp3 = 5;
    ParsePosition pp4( pp3 );
    if ((pp2 != pp3) && (pp3 == pp4)) {
        it_logln("PP copy contructor, operator== and operator != tested.");
    }else{
        it_errln("*** PP operator== or operator != result");
    }

    ParsePosition pp5;
    pp5 = pp4;
    if ((pp4 == pp5) && (!(pp4 != pp5))) {
        it_logln("PP operator= tested.");
    }else{
        it_errln("*** PP operator= operator== or operator != result");
    }


}

#include "unicode/decimfmt.h"

void test_FieldPosition_example( void )
{
    //***** no error detection yet !!!!!!!
    //***** this test is for compiler checks and visual verification only.
    double doubleNum[] = { 123456789.0, -12345678.9, 1234567.89, -123456.789,
        12345.6789, -1234.56789, 123.456789, -12.3456789, 1.23456789};
    int32_t dNumSize = (int32_t)(sizeof(doubleNum)/sizeof(double));

    UErrorCode status = U_ZERO_ERROR;
    DecimalFormat* fmt = (DecimalFormat*) NumberFormat::createInstance(status);
    if (U_FAILURE(status)) {
        it_dataerrln("NumberFormat::createInstance() error");
        return;
    }
    fmt->setDecimalSeparatorAlwaysShown(TRUE);
    
    const int32_t tempLen = 20;
    char temp[tempLen];
    
    for (int32_t i=0; i<dNumSize; i++) {
        FieldPosition pos(NumberFormat::INTEGER_FIELD);
        UnicodeString buf;
        //char fmtText[tempLen];
        //ToCharString(fmt->format(doubleNum[i], buf, pos), fmtText);
        UnicodeString res = fmt->format(doubleNum[i], buf, pos);
        for (int32_t j=0; j<tempLen; j++) temp[j] = '='; // clear with spaces
        int32_t tempOffset = (tempLen <= (tempLen - pos.getEndIndex())) ? 
            tempLen : (tempLen - pos.getEndIndex());
        temp[tempOffset] = '\0';
        it_logln(UnicodeString("FP ") + UnicodeString(temp) + res);
    }
    delete fmt;
    
    it_logln("");

}

void test_FieldPosition( void )
{

    FieldPosition fp( 7 );

    if (fp.getField() == 7) {
        it_logln("FP constructor(int32_t) and getField tested.");
    }else{
        it_errln("*** FP constructor(int32_t) or getField");
    }

    FieldPosition* fph = new FieldPosition( 3 );
    if ( fph->getField() != 3) it_errln("*** FP getField or heap constr.");
    delete fph;

    UBool err1 = FALSE;
    UBool err2 = FALSE;
    UBool err3 = FALSE;
    for (int32_t i = -50; i < 50; i++ ) {
        fp.setField( i+8 );
        fp.setBeginIndex( i+6 );
        fp.setEndIndex( i+7 );
        if (fp.getField() != i+8)  err1 = TRUE;
        if (fp.getBeginIndex() != i+6) err2 = TRUE;
        if (fp.getEndIndex() != i+7) err3 = TRUE;
    }
    if (!err1) {
        it_logln("FP setField and getField tested.");
    }else{
        it_errln("*** FP setField or getField");
    }
    if (!err2) {
        it_logln("FP setBeginIndex and getBeginIndex tested.");
    }else{
        it_errln("*** FP setBeginIndex or getBeginIndex");
    }
    if (!err3) {
        it_logln("FP setEndIndex and getEndIndex tested.");
    }else{
        it_errln("*** FP setEndIndex or getEndIndex");
    }

    it_logln("");

}

void test_Formattable( void )
{
    UErrorCode status = U_ZERO_ERROR;
    Formattable* ftp = new Formattable();
    if (!ftp || !(ftp->getType() == Formattable::kLong) || !(ftp->getLong() == 0)) {
        it_errln("*** Formattable constructor or getType or getLong");
    }
    delete ftp;

    Formattable fta, ftb;
    fta.setLong(1); ftb.setLong(2);
    if ((fta != ftb) || !(fta == ftb)) {
        it_logln("FT setLong, operator== and operator!= tested.");
        status = U_ZERO_ERROR;
        fta.getLong(&status);
        if ( status == U_INVALID_FORMAT_ERROR){
            it_errln("*** FT getLong(UErrorCode* status) failed on real Long");
        } else {
            it_logln("FT getLong(UErrorCode* status) tested.");
        }
    }else{
        it_errln("*** Formattable setLong or operator== or !=");
    }
    fta = ftb;
    if ((fta == ftb) || !(fta != ftb)) {
        it_logln("FT operator= tested.");
    }else{
        it_errln("*** FT operator= or operator== or operator!=");
    }
    
    fta.setDouble( 3.0 );
    if ((fta.getType() == Formattable::kDouble) && (fta.getDouble() == 3.0)) {
        it_logln("FT set- and getDouble tested.");
    }else{
        it_errln("*** FT set- or getDouble");
    }
    
    fta.getDate(status = U_ZERO_ERROR);
    if (status != U_INVALID_FORMAT_ERROR){
        it_errln("*** FT getDate with status should fail on non-Date");
    }
    fta.setDate( 4.0 );
    if ((fta.getType() == Formattable::kDate) && (fta.getDate() == 4.0)) {
        it_logln("FT set- and getDate tested.");	  
        status = U_ZERO_ERROR;
        fta.getDate(status);
        if ( status == U_INVALID_FORMAT_ERROR){
            it_errln("*** FT getDate with status failed on real Date");
        } else {
            it_logln("FT getDate with status tested.");
        }
    }else{
        it_errln("*** FT set- or getDate");
    }

    status = U_ZERO_ERROR;
    fta.getLong(&status);
    if (status != U_INVALID_FORMAT_ERROR){
        it_errln("*** FT getLong(UErrorCode* status) should fail on non-Long");
    }

    fta.setString("abc");
    const Formattable ftc(fta);
    UnicodeString res;

    {
        UBool t;
        t = (fta.getType() == Formattable::kString) 
            && (fta.getString(res) == "abc")
            && (fta.getString() == "abc");
        res = fta.getString(status = U_ZERO_ERROR);
        t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
        res = ftc.getString(status = U_ZERO_ERROR);
        t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
        ftc.getString(res,status = U_ZERO_ERROR);
        t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc"); 
        if (t) {
            it_logln("FT set- and getString tested.");
        }else{
            it_errln("*** FT set- or getString");
        }
    }

    UnicodeString ucs = "unicode-string";
    UnicodeString* ucs_ptr = new UnicodeString("pointed-to-unicode-string");

    const Formattable ftarray[] = 
    {
        Formattable( 1.0, Formattable::kIsDate ),
        2.0,
        (int32_t)3,
        ucs,
        ucs_ptr
    };
    const int32_t ft_cnt = LENGTHOF(ftarray);
    Formattable ft_arr( ftarray, ft_cnt );
    UnicodeString temp;
    if ((ft_arr[0].getType() == Formattable::kDate)   && (ft_arr[0].getDate()   == 1.0)
     && (ft_arr[1].getType() == Formattable::kDouble) && (ft_arr[1].getDouble() == 2.0)
     && (ft_arr[2].getType() == Formattable::kLong)   && (ft_arr[2].getLong()   == (int32_t)3)
     && (ft_arr[3].getType() == Formattable::kString) && (ft_arr[3].getString(temp) == ucs)
     && (ft_arr[4].getType() == Formattable::kString) && (ft_arr[4].getString(temp) == *ucs_ptr) ) {
        it_logln("FT constr. for date, double, long, ustring, ustring* and array tested");
    }else{
        it_errln("*** FT constr. for date, double, long, ustring, ustring* or array");
    }

    int32_t i, res_cnt;
    const Formattable* res_array = ft_arr.getArray( res_cnt );
    if (res_cnt == ft_cnt) {
        UBool same  = TRUE;
        for (i = 0; i < res_cnt; i++ ) {
            if (res_array[i] != ftarray[i]) {
                same = FALSE;
            }
        }
        if (same) {
            it_logln("FT getArray tested");
            res_array = ft_arr.getArray( res_cnt, status = U_ZERO_ERROR);
            if (status == U_INVALID_FORMAT_ERROR){
                it_errln("*** FT getArray with status failed on real array");
            } else {
                it_logln("FT getArray with status tested on real array");
            }
        }else{
            it_errln("*** FT getArray comparison");
        }
    }else{
        it_errln(UnicodeString("*** FT getArray count res_cnt=") + res_cnt + UnicodeString("ft_cnt=") + ft_cnt);
    }
    
    res_array = fta.getArray(res_cnt, status = U_ZERO_ERROR);
    if (status == U_INVALID_FORMAT_ERROR){
        if (res_cnt == 0 && res_array == NULL){
            it_logln("FT getArray with status tested on non array");
        } else {
            it_errln("*** FT getArray with status return values are not consistent");
        }
    } else {
        it_errln("*** FT getArray with status should fail on non-array");
    }


    Formattable *pf;
    for(i = 0; i < ft_cnt; ++i) {
        pf = ftarray[i].clone();
        if(pf == (ftarray + i) || *pf != ftarray[i]) {
            it_errln(UnicodeString("Formattable.clone() failed for item ") + i);
        }
        delete pf;
    }

    const Formattable ftarr1[] = { Formattable( (int32_t)1 ), Formattable( (int32_t)2 ) };
    const Formattable ftarr2[] = { Formattable( (int32_t)3 ), Formattable( (int32_t)4 ) };

    const int32_t ftarr1_cnt = (int32_t)(sizeof(ftarr1) / sizeof(Formattable));
    const int32_t ftarr2_cnt = (int32_t)(sizeof(ftarr2) / sizeof(Formattable));

    ft_arr.setArray( ftarr1, ftarr1_cnt );
    if ((ft_arr[0].getType() == Formattable::kLong) && (ft_arr[0].getLong() == (int32_t)1)) {
        it_logln("FT setArray tested");
    }else{
        it_errln("*** FT setArray");
    }

    Formattable* ft_dynarr = new Formattable[ftarr2_cnt];
    for (i = 0; i < ftarr2_cnt; i++ ) {
        ft_dynarr[i] = ftarr2[i];
    }
    if ((ft_dynarr[0].getType() == Formattable::kLong) && (ft_dynarr[0].getLong() == (int32_t)3)
     && (ft_dynarr[1].getType() == Formattable::kLong) && (ft_dynarr[1].getLong() == (int32_t)4)) {
        it_logln("FT operator= and array operations tested");
    }else{
        it_errln("*** FT operator= or array operations");
    }

    ft_arr.adoptArray( ft_dynarr, ftarr2_cnt );
    if ((ft_arr[0].getType() == Formattable::kLong) && (ft_arr[0].getLong() == (int32_t)3)
     && (ft_arr[1].getType() == Formattable::kLong) && (ft_arr[1].getLong() == (int32_t)4)) {
        it_logln("FT adoptArray tested");
    }else{
        it_errln("*** FT adoptArray or operator[]");
    }

    ft_arr.setLong(0);   // calls 'dispose' and deletes adopted array !

    UnicodeString* ucs_dyn = new UnicodeString("ttt");
    UnicodeString tmp2;

    fta.adoptString( ucs_dyn );
    if ((fta.getType() == Formattable::kString) && (fta.getString(tmp2) == "ttt")) {
        it_logln("FT adoptString tested");
    }else{
        it_errln("*** FT adoptString or getString");
    }
    fta.setLong(0);   // calls 'dispose' and deletes adopted string !

    it_logln();
}

void TestFormatSmallClasses::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    switch (index) {
        case 0: name = "pp"; 
                if (exec) logln("TestSuite Format/SmallClasses/ParsePosition (f/chc/sma/pp): ");
                if (exec) test_ParsePosition(); 
                break;
        case 1: name = "fp"; 
                if (exec) logln("TestSuite Format/SmallClasses/FieldPosition (f/chc/sma/fp): ");
                if (exec) test_FieldPosition(); 
                break;
        case 2: name = "fpe"; 
                if (exec) logln("TestSuite Format/SmallClasses/FieldPositionExample (f/chc/sma/fpe): ");
                if (exec) test_FieldPosition_example(); 
                break;
        case 3: name = "ft"; 
                if (exec) logln("TestSuite Format/SmallClasses/Formattable (f/chc/sma/ft): ");
                if (exec) test_Formattable(); 
                break;
        default: name = ""; break; //needed to end loop
    }
}

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
b75a7d8f	1
374ca955	2	/***********************************************************************
b75a7d8f	3	* COPYRIGHT:
51004dcb	4	* Copyright (c) 1997-2012, International Business Machines Corporation
374ca955 A	5	* and others. All Rights Reserved.
374ca955 A	6	***********************************************************************/
b75a7d8f A	7
	8	#include "unicode/utypes.h"
	9
	10	#if !UCONFIG_NO_FORMATTING
	11
	12	#include "intltest.h"
	13	#include "tfsmalls.h"
	14
	15	#include "unicode/msgfmt.h"
	16	#include "unicode/choicfmt.h"
	17
	18	#include "unicode/parsepos.h"
	19	#include "unicode/fieldpos.h"
	20	#include "unicode/fmtable.h"
	21
374ca955	22	#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
b75a7d8f A	23
	24	/static UBool chkstatus( UErrorCode &status, char msg = NULL )
	25	{
	26	UBool ok = (status == U_ZERO_ERROR);
	27	if (!ok) it_errln( msg );
	28	return ok;
	29	}*/
	30
	31	void test_ParsePosition( void )
	32	{
	33	ParsePosition* pp1 = new ParsePosition();
	34	if (pp1 && (pp1->getIndex() == 0)) {
374ca955	35	it_logln("PP constructor() tested.");
b75a7d8f A	36	}else{
	37	it_errln("*** PP getIndex or constructor() result");
	38	}
	39	delete pp1;
	40
	41
	42	{
	43	int32_t to = 5;
	44	ParsePosition pp2( to );
	45	if (pp2.getIndex() == 5) {
374ca955	46	it_logln("PP getIndex and constructor(int32_t) tested.");
b75a7d8f A	47	}else{
	48	it_errln("*** PP getIndex or constructor(int32_t) result");
	49	}
	50	pp2.setIndex( 3 );
	51	if (pp2.getIndex() == 3) {
374ca955	52	it_logln("PP setIndex tested.");
b75a7d8f A	53	}else{
	54	it_errln("*** PP getIndex or setIndex result");
	55	}
	56	}
	57
	58	ParsePosition pp2, pp3;
	59	pp2 = 3;
	60	pp3 = 5;
	61	ParsePosition pp4( pp3 );
	62	if ((pp2 != pp3) && (pp3 == pp4)) {
374ca955	63	it_logln("PP copy contructor, operator== and operator != tested.");
b75a7d8f A	64	}else{
	65	it_errln("*** PP operator== or operator != result");
	66	}
	67
	68	ParsePosition pp5;
	69	pp5 = pp4;
	70	if ((pp4 == pp5) && (!(pp4 != pp5))) {
374ca955	71	it_logln("PP operator= tested.");
b75a7d8f A	72	}else{
	73	it_errln("*** PP operator= operator== or operator != result");
	74	}
	75
	76
	77	}
	78
	79	#include "unicode/decimfmt.h"
	80
	81	void test_FieldPosition_example( void )
	82	{
	83	//***** no error detection yet !!!!!!!
	84	//***** this test is for compiler checks and visual verification only.
	85	double doubleNum[] = { 123456789.0, -12345678.9, 1234567.89, -123456.789,
	86	12345.6789, -1234.56789, 123.456789, -12.3456789, 1.23456789};
	87	int32_t dNumSize = (int32_t)(sizeof(doubleNum)/sizeof(double));
	88
	89	UErrorCode status = U_ZERO_ERROR;
	90	DecimalFormat* fmt = (DecimalFormat*) NumberFormat::createInstance(status);
73c04bcf A	91	if (U_FAILURE(status)) {
	92	it_dataerrln("NumberFormat::createInstance() error");
	93	return;
	94	}
b75a7d8f A	95	fmt->setDecimalSeparatorAlwaysShown(TRUE);
	96
	97	const int32_t tempLen = 20;
	98	char temp[tempLen];
	99
	100	for (int32_t i=0; i<dNumSize; i++) {
	101	FieldPosition pos(NumberFormat::INTEGER_FIELD);
	102	UnicodeString buf;
	103	//char fmtText[tempLen];
	104	//ToCharString(fmt->format(doubleNum[i], buf, pos), fmtText);
	105	UnicodeString res = fmt->format(doubleNum[i], buf, pos);
	106	for (int32_t j=0; j<tempLen; j++) temp[j] = '='; // clear with spaces
	107	int32_t tempOffset = (tempLen <= (tempLen - pos.getEndIndex())) ?
	108	tempLen : (tempLen - pos.getEndIndex());
	109	temp[tempOffset] = '\0';
374ca955	110	it_logln(UnicodeString("FP ") + UnicodeString(temp) + res);
b75a7d8f A	111	}
	112	delete fmt;
	113
374ca955	114	it_logln("");
b75a7d8f A	115
	116	}
	117
	118	void test_FieldPosition( void )
	119	{
	120
	121	FieldPosition fp( 7 );
	122
	123	if (fp.getField() == 7) {
374ca955	124	it_logln("FP constructor(int32_t) and getField tested.");
b75a7d8f A	125	}else{
	126	it_errln("*** FP constructor(int32_t) or getField");
	127	}
	128
	129	FieldPosition* fph = new FieldPosition( 3 );
	130	if ( fph->getField() != 3) it_errln("*** FP getField or heap constr.");
	131	delete fph;
	132
	133	UBool err1 = FALSE;
	134	UBool err2 = FALSE;
	135	UBool err3 = FALSE;
	136	for (int32_t i = -50; i < 50; i++ ) {
	137	fp.setField( i+8 );
	138	fp.setBeginIndex( i+6 );
	139	fp.setEndIndex( i+7 );
	140	if (fp.getField() != i+8) err1 = TRUE;
	141	if (fp.getBeginIndex() != i+6) err2 = TRUE;
	142	if (fp.getEndIndex() != i+7) err3 = TRUE;
	143	}
	144	if (!err1) {
374ca955	145	it_logln("FP setField and getField tested.");
b75a7d8f A	146	}else{
	147	it_errln("*** FP setField or getField");
	148	}
	149	if (!err2) {
374ca955	150	it_logln("FP setBeginIndex and getBeginIndex tested.");
b75a7d8f A	151	}else{
	152	it_errln("*** FP setBeginIndex or getBeginIndex");
	153	}
	154	if (!err3) {
374ca955	155	it_logln("FP setEndIndex and getEndIndex tested.");
b75a7d8f A	156	}else{
	157	it_errln("*** FP setEndIndex or getEndIndex");
	158	}
	159
374ca955	160	it_logln("");
b75a7d8f A	161
	162	}
	163
	164	void test_Formattable( void )
	165	{
73c04bcf	166	UErrorCode status = U_ZERO_ERROR;
b75a7d8f A	167	Formattable* ftp = new Formattable();
	168	if (!ftp \|\| !(ftp->getType() == Formattable::kLong) \|\| !(ftp->getLong() == 0)) {
	169	it_errln("*** Formattable constructor or getType or getLong");
	170	}
	171	delete ftp;
	172
	173	Formattable fta, ftb;
	174	fta.setLong(1); ftb.setLong(2);
	175	if ((fta != ftb) \|\| !(fta == ftb)) {
374ca955	176	it_logln("FT setLong, operator== and operator!= tested.");
73c04bcf A	177	status = U_ZERO_ERROR;
	178	fta.getLong(&status);
	179	if ( status == U_INVALID_FORMAT_ERROR){
	180	it_errln("*** FT getLong(UErrorCode* status) failed on real Long");
	181	} else {
	182	it_logln("FT getLong(UErrorCode* status) tested.");
	183	}
b75a7d8f A	184	}else{
	185	it_errln("*** Formattable setLong or operator== or !=");
	186	}
	187	fta = ftb;
	188	if ((fta == ftb) \|\| !(fta != ftb)) {
374ca955	189	it_logln("FT operator= tested.");
b75a7d8f A	190	}else{
	191	it_errln("*** FT operator= or operator== or operator!=");
	192	}
	193
	194	fta.setDouble( 3.0 );
	195	if ((fta.getType() == Formattable::kDouble) && (fta.getDouble() == 3.0)) {
374ca955	196	it_logln("FT set- and getDouble tested.");
b75a7d8f A	197	}else{
	198	it_errln("*** FT set- or getDouble");
	199	}
73c04bcf A	200
	201	fta.getDate(status = U_ZERO_ERROR);
	202	if (status != U_INVALID_FORMAT_ERROR){
	203	it_errln("*** FT getDate with status should fail on non-Date");
	204	}
b75a7d8f A	205	fta.setDate( 4.0 );
b75a7d8f A	206	if ((fta.getType() == Formattable::kDate) && (fta.getDate() == 4.0)) {
73c04bcf A	207	it_logln("FT set- and getDate tested.");
	208	status = U_ZERO_ERROR;
	209	fta.getDate(status);
	210	if ( status == U_INVALID_FORMAT_ERROR){
	211	it_errln("*** FT getDate with status failed on real Date");
	212	} else {
	213	it_logln("FT getDate with status tested.");
	214	}
b75a7d8f A	215	}else{
	216	it_errln("*** FT set- or getDate");
	217	}
	218
73c04bcf A	219	status = U_ZERO_ERROR;
	220	fta.getLong(&status);
	221	if (status != U_INVALID_FORMAT_ERROR){
	222	it_errln("*** FT getLong(UErrorCode* status) should fail on non-Long");
	223	}
	224
b75a7d8f	225	fta.setString("abc");
73c04bcf	226	const Formattable ftc(fta);
b75a7d8f	227	UnicodeString res;
b75a7d8f	228
73c04bcf A	229	{
	230	UBool t;
	231	t = (fta.getType() == Formattable::kString)
	232	&& (fta.getString(res) == "abc")
	233	&& (fta.getString() == "abc");
	234	res = fta.getString(status = U_ZERO_ERROR);
	235	t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
	236	res = ftc.getString(status = U_ZERO_ERROR);
	237	t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
	238	ftc.getString(res,status = U_ZERO_ERROR);
	239	t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
	240	if (t) {
	241	it_logln("FT set- and getString tested.");
	242	}else{
	243	it_errln("*** FT set- or getString");
	244	}
	245	}
b75a7d8f A	246
	247	UnicodeString ucs = "unicode-string";
	248	UnicodeString* ucs_ptr = new UnicodeString("pointed-to-unicode-string");
	249
	250	const Formattable ftarray[] =
	251	{
	252	Formattable( 1.0, Formattable::kIsDate ),
	253	2.0,
	254	(int32_t)3,
	255	ucs,
	256	ucs_ptr
	257	};
374ca955	258	const int32_t ft_cnt = LENGTHOF(ftarray);
b75a7d8f A	259	Formattable ft_arr( ftarray, ft_cnt );
	260	UnicodeString temp;
	261	if ((ft_arr[0].getType() == Formattable::kDate) && (ft_arr[0].getDate() == 1.0)
	262	&& (ft_arr[1].getType() == Formattable::kDouble) && (ft_arr[1].getDouble() == 2.0)
	263	&& (ft_arr[2].getType() == Formattable::kLong) && (ft_arr[2].getLong() == (int32_t)3)
	264	&& (ft_arr[3].getType() == Formattable::kString) && (ft_arr[3].getString(temp) == ucs)
	265	&& (ft_arr[4].getType() == Formattable::kString) && (ft_arr[4].getString(temp) == *ucs_ptr) ) {
374ca955	266	it_logln("FT constr. for date, double, long, ustring, ustring* and array tested");
b75a7d8f A	267	}else{
	268	it_errln("*** FT constr. for date, double, long, ustring, ustring* or array");
	269	}
	270
374ca955	271	int32_t i, res_cnt;
b75a7d8f A	272	const Formattable* res_array = ft_arr.getArray( res_cnt );
	273	if (res_cnt == ft_cnt) {
	274	UBool same = TRUE;
374ca955	275	for (i = 0; i < res_cnt; i++ ) {
b75a7d8f A	276	if (res_array[i] != ftarray[i]) {
	277	same = FALSE;
	278	}
	279	}
	280	if (same) {
374ca955	281	it_logln("FT getArray tested");
73c04bcf A	282	res_array = ft_arr.getArray( res_cnt, status = U_ZERO_ERROR);
	283	if (status == U_INVALID_FORMAT_ERROR){
	284	it_errln("*** FT getArray with status failed on real array");
	285	} else {
	286	it_logln("FT getArray with status tested on real array");
	287	}
b75a7d8f A	288	}else{
	289	it_errln("*** FT getArray comparison");
	290	}
	291	}else{
374ca955 A	292	it_errln(UnicodeString("*** FT getArray count res_cnt=") + res_cnt + UnicodeString("ft_cnt=") + ft_cnt);
374ca955 A	293	}
73c04bcf A	294
	295	res_array = fta.getArray(res_cnt, status = U_ZERO_ERROR);
	296	if (status == U_INVALID_FORMAT_ERROR){
	297	if (res_cnt == 0 && res_array == NULL){
	298	it_logln("FT getArray with status tested on non array");
	299	} else {
	300	it_errln("*** FT getArray with status return values are not consistent");
	301	}
	302	} else {
	303	it_errln("*** FT getArray with status should fail on non-array");
	304	}
374ca955 A	305
	306
	307	Formattable *pf;
	308	for(i = 0; i < ft_cnt; ++i) {
	309	pf = ftarray[i].clone();
	310	if(pf == (ftarray + i) \|\| *pf != ftarray[i]) {
51004dcb	311	it_errln(UnicodeString("Formattable.clone() failed for item ") + i);
374ca955 A	312	}
374ca955 A	313	delete pf;
b75a7d8f A	314	}
	315
	316	const Formattable ftarr1[] = { Formattable( (int32_t)1 ), Formattable( (int32_t)2 ) };
	317	const Formattable ftarr2[] = { Formattable( (int32_t)3 ), Formattable( (int32_t)4 ) };
	318
	319	const int32_t ftarr1_cnt = (int32_t)(sizeof(ftarr1) / sizeof(Formattable));
	320	const int32_t ftarr2_cnt = (int32_t)(sizeof(ftarr2) / sizeof(Formattable));
	321
	322	ft_arr.setArray( ftarr1, ftarr1_cnt );
	323	if ((ft_arr[0].getType() == Formattable::kLong) && (ft_arr[0].getLong() == (int32_t)1)) {
374ca955	324	it_logln("FT setArray tested");
b75a7d8f A	325	}else{
	326	it_errln("*** FT setArray");
	327	}
	328
	329	Formattable* ft_dynarr = new Formattable[ftarr2_cnt];
374ca955	330	for (i = 0; i < ftarr2_cnt; i++ ) {
b75a7d8f A	331	ft_dynarr[i] = ftarr2[i];
	332	}
	333	if ((ft_dynarr[0].getType() == Formattable::kLong) && (ft_dynarr[0].getLong() == (int32_t)3)
	334	&& (ft_dynarr[1].getType() == Formattable::kLong) && (ft_dynarr[1].getLong() == (int32_t)4)) {
374ca955	335	it_logln("FT operator= and array operations tested");
b75a7d8f A	336	}else{
	337	it_errln("*** FT operator= or array operations");
	338	}
	339
	340	ft_arr.adoptArray( ft_dynarr, ftarr2_cnt );
	341	if ((ft_arr[0].getType() == Formattable::kLong) && (ft_arr[0].getLong() == (int32_t)3)
	342	&& (ft_arr[1].getType() == Formattable::kLong) && (ft_arr[1].getLong() == (int32_t)4)) {
374ca955	343	it_logln("FT adoptArray tested");
b75a7d8f A	344	}else{
	345	it_errln("*** FT adoptArray or operator[]");
	346	}
	347
	348	ft_arr.setLong(0); // calls 'dispose' and deletes adopted array !
	349
	350	UnicodeString* ucs_dyn = new UnicodeString("ttt");
	351	UnicodeString tmp2;
	352
	353	fta.adoptString( ucs_dyn );
	354	if ((fta.getType() == Formattable::kString) && (fta.getString(tmp2) == "ttt")) {
374ca955	355	it_logln("FT adoptString tested");
b75a7d8f A	356	}else{
	357	it_errln("*** FT adoptString or getString");
	358	}
	359	fta.setLong(0); // calls 'dispose' and deletes adopted string !
	360
374ca955	361	it_logln();
b75a7d8f A	362	}
	363
	364	void TestFormatSmallClasses::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	365	{
	366	switch (index) {
	367	case 0: name = "pp";
	368	if (exec) logln("TestSuite Format/SmallClasses/ParsePosition (f/chc/sma/pp): ");
	369	if (exec) test_ParsePosition();
	370	break;
	371	case 1: name = "fp";
	372	if (exec) logln("TestSuite Format/SmallClasses/FieldPosition (f/chc/sma/fp): ");
	373	if (exec) test_FieldPosition();
	374	break;
	375	case 2: name = "fpe";
	376	if (exec) logln("TestSuite Format/SmallClasses/FieldPositionExample (f/chc/sma/fpe): ");
	377	if (exec) test_FieldPosition_example();
	378	break;
	379	case 3: name = "ft";
	380	if (exec) logln("TestSuite Format/SmallClasses/Formattable (f/chc/sma/ft): ");
	381	if (exec) test_Formattable();
	382	break;
	383	default: name = ""; break; //needed to end loop
	384	}
	385	}
	386
	387	#endif /* #if !UCONFIG_NO_FORMATTING */