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

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2010, International Business Machines Corporation and
 * others. All Rights Reserved.
 * Copyright (C) 2010 , Yahoo! Inc. 
 ********************************************************************/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "selfmts.h"
#include "cmemory.h"
#include "unicode/selfmt.h"
#include "stdio.h"

#define SIMPLE_PATTERN_STRING                                                    "feminine {feminineVerbValue} other{otherVerbValue}"


#define SELECT_PATTERN_DATA 4
#define SELECT_SYNTAX_DATA 10
#define EXP_FORMAT_RESULT_DATA 12
#define NUM_OF_FORMAT_ARGS 3

#define VERBOSE_INT(x) {logln("%s:%d:  int %s=%d\n", __FILE__, __LINE__, #x, (x));}
#define VERBOSE_USTRING(text) {logln("%s:%d: UnicodeString %s(%d) = ", __FILE__, __LINE__, #text, text.length()); logln(UnicodeString(" \"")+text+UnicodeString("\";"));}


void SelectFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln("TestSuite SelectFormat");
    switch (index) {
        TESTCASE(0, selectFormatAPITest);
        TESTCASE(1, selectFormatUnitTest);
        default: name = "";
            break;
    }
}

/**
 * Unit tests of SelectFormat class.
 */
void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
{
  const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */

    UnicodeString patternTestData[SELECT_PATTERN_DATA] = {
        UNICODE_STRING_SIMPLE("fem {femValue} other{even}"),
        UNICODE_STRING_SIMPLE("other{odd or even}"),
        UNICODE_STRING_SIMPLE("odd{The number {0, number, integer} is odd.}other{The number {0, number, integer} is even.}"),
        UNICODE_STRING_SIMPLE("odd{The number {1} is odd}other{The number {1} is even}"),
    };

    UnicodeString formatArgs[NUM_OF_FORMAT_ARGS] = {
        UNICODE_STRING_SIMPLE("fem"),
        UNICODE_STRING_SIMPLE("other"),
        UNICODE_STRING_SIMPLE("odd")
    };

    UnicodeString expFormatResult[][NUM_OF_FORMAT_ARGS] = {
        {
            UNICODE_STRING_SIMPLE("femValue"),
            UNICODE_STRING_SIMPLE("even"),
            UNICODE_STRING_SIMPLE("even")
        },
        {
            UNICODE_STRING_SIMPLE("odd or even"),
            UNICODE_STRING_SIMPLE("odd or even"),
            UNICODE_STRING_SIMPLE("odd or even"),
        },
        {
            UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
            UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
            UNICODE_STRING_SIMPLE("The number {0, number, integer} is odd."),
        },
        {
            UNICODE_STRING_SIMPLE("The number {1} is even"),
            UNICODE_STRING_SIMPLE("The number {1} is even"),
            UNICODE_STRING_SIMPLE("The number {1} is odd"),
        }
    };

    UnicodeString checkSyntaxData[SELECT_SYNTAX_DATA] = {
        UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
        UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
        UNICODE_STRING_SIMPLE("odd{foo}"),
        UNICODE_STRING_SIMPLE("1odd{foo} other{bar}"),
        UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
        UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
        UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
        UNICODE_STRING_SIMPLE("odd{foo1}other{foo2}}"),  
        UNICODE_STRING_SIMPLE("odd{foo1}other{{foo2}"),  
        UNICODE_STRING_SIMPLE("odd{fo{o1}other{foo2}}")
    };

    UErrorCode expErrorCodes[SELECT_SYNTAX_DATA]={
        U_DUPLICATE_KEYWORD, 
        U_DUPLICATE_KEYWORD,  
        U_DEFAULT_KEYWORD_MISSING,
        U_PATTERN_SYNTAX_ERROR,
        U_PATTERN_SYNTAX_ERROR,
        U_PATTERN_SYNTAX_ERROR,
        U_PATTERN_SYNTAX_ERROR,
        U_PATTERN_SYNTAX_ERROR,  
        U_PATTERN_SYNTAX_ERROR,  
        U_DEFAULT_KEYWORD_MISSING
    };

    UErrorCode status = U_ZERO_ERROR;
    VERBOSE_USTRING(SIMPLE_PATTERN);
    SelectFormat* selFmt = new SelectFormat( SIMPLE_PATTERN , status); 
    if (U_FAILURE(status)) {
        dataerrln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
        return;
    }
    
    // ======= Test SelectFormat pattern syntax.
    logln("SelectFormat Unit Test : Testing SelectFormat pattern syntax.");
    for (int32_t i=0; i<SELECT_SYNTAX_DATA; ++i) {
        status = U_ZERO_ERROR;
        VERBOSE_INT(i);
        VERBOSE_USTRING(checkSyntaxData[i]);
        selFmt->applyPattern(checkSyntaxData[i], status);
        if( status!= expErrorCodes[i] ){
            errln("\nERROR: Unexpected result - SelectFormat Unit Test failed to detect syntax error with pattern: "+checkSyntaxData[i]+" and expected status="+ u_errorName(expErrorCodes[i]) + " and resulted status="+u_errorName(status));
        }
    }

    delete selFmt;
    selFmt = NULL;

    logln("SelectFormat Unit Test : Creating format object for Testing applying various patterns");
    status = U_ZERO_ERROR;
    selFmt = new SelectFormat( SIMPLE_PATTERN , status); 
    //SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status); 
    if (U_FAILURE(status)) {
        errln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
        return;
    }

    // ======= Test applying and formatting with various pattern
    logln("SelectFormat Unit test: Testing  applyPattern() and format() ...");
    UnicodeString result;
    FieldPosition ignore(FieldPosition::DONT_CARE);

    for(int32_t i=0; i<SELECT_PATTERN_DATA; ++i) {
        status = U_ZERO_ERROR;
        selFmt->applyPattern(patternTestData[i], status);
        if (U_FAILURE(status)) {
            errln("ERROR: SelectFormat Unit Test failed to apply pattern- "+patternTestData[i] );
            continue;
        }

        //Format with the keyword array
        for(int32_t j=0; j<3; j++) {
            result.remove();
            selFmt->format( formatArgs[j], result , ignore , status);
            if (U_FAILURE(status)) {
                errln("ERROR: SelectFormat Unit test failed in format() with argument: "+ formatArgs[j] + " and error is " + u_errorName(status) );
            }else{
                if( result != expFormatResult[i][j] ){
                    errln("ERROR: SelectFormat Unit test failed in format() with unexpected result\n  with argument: "+ formatArgs[j] + "\n result obtained: " + result + "\n and expected is: " + expFormatResult[i][j] );
                }
            }
        }
    }

    //Test with an invalid keyword
    logln("SelectFormat Unit test: Testing  format() with keyword method and with invalid keywords...");
    status = U_ZERO_ERROR;
    result.remove();
    UnicodeString keywords[] = {
        "9Keyword-_",       //Starts with a digit
        "-Keyword-_",       //Starts with a hyphen
        "_Keyword-_",       //Starts with a underscore
        "\\u00E9Keyword-_", //Starts with non-ASCII character
        "Key*word-_",       //Contains a sepial character not allowed
        "*Keyword-_"        //Starts with a sepial character not allowed
    };

    delete selFmt;
    selFmt = NULL;

    selFmt = new SelectFormat( SIMPLE_PATTERN , status); 
    for (int32_t i = 0; i< 6; i++ ){
        status = U_ZERO_ERROR;
        selFmt->format( keywords[i], result , ignore , status);
        if (!U_FAILURE(status)) {
            errln("ERROR: SelectFormat Unit test failed in format() with keyWord and with an invalid keyword as : "+ keywords[i]);
        }
    }

    delete selFmt;
}

/**
 * Test various generic API methods of SelectFormat for Basic API usage.
 * This is to make sure the API test coverage is 100% .
 */
void SelectFormatTest::selectFormatAPITest(/*char *par*/)
{
  const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */
    int numOfConstructors =3;
    UErrorCode status[3];
    SelectFormat* selFmt[3] = { NULL, NULL, NULL };

    // ========= Test constructors
    logln("SelectFormat API test: Testing SelectFormat constructors ...");
    for (int32_t i=0; i< numOfConstructors; ++i) {
        status[i] = U_ZERO_ERROR;
    }

    selFmt[0]= new SelectFormat(SIMPLE_PATTERN, status[0]);
    if ( U_FAILURE(status[0]) ) {
      errln("ERROR: SelectFormat API test constructor with pattern and status failed! with %s\n", u_errorName(status[0]));
        return;
    }

    // =========== Test copy constructor
    logln("SelectFormat API test: Testing copy constructor and == operator ...");
    SelectFormat fmt = *selFmt[0];
    SelectFormat* dupPFmt = new SelectFormat(fmt);
    if ((*selFmt[0]) != (*dupPFmt)) {
        errln("ERROR: SelectFormat API test Failed in copy constructor or == operator!");
    }
    delete dupPFmt;
    
    // ======= Test clone && == operator.
    logln("SelectFormat API test: Testing clone and == operator ...");
    if ( U_SUCCESS(status[0])  ) {
        selFmt[1] = (SelectFormat*)selFmt[0]->clone();
        if (selFmt[1]!=NULL) {
            if ( *selFmt[1] != *selFmt[0] ) {
                errln("ERROR: SelectFormat API test clone test failed!");
            }
        } else {
          errln("ERROR: SelectFormat API test clone test failed with NULL!");
          return;
        }
    } else {
      errln("ERROR: could not create [0]: %s\n", u_errorName(status[0]));
      return;
    }

    // ======= Test assignment operator && == operator.
    logln("SelectFormat API test: Testing assignment operator and == operator ...");
    selFmt[2]= new SelectFormat(SIMPLE_PATTERN, status[2]);
    if ( U_SUCCESS(status[2]) ) {
        *selFmt[1] = *selFmt[2];
        if (selFmt[1]!=NULL) {
            if ( (*selFmt[1] != *selFmt[2]) ) {
                errln("ERROR: SelectFormat API test assignment operator test failed!");
            }
        }
        delete selFmt[1];
    }
    else {
         errln("ERROR: SelectFormat constructor failed in assignment operator!");
    }
    delete selFmt[0];
    delete selFmt[2];

    // ======= Test getStaticClassID() and getStaticClassID()
    logln("SelectFormat API test: Testing getStaticClassID() and getStaticClassID() ...");
    UErrorCode status1 = U_ZERO_ERROR;
    SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status1); 
    if( U_FAILURE(status1)) {
        errln("ERROR: SelectFormat constructor failed in staticClassID test! Exitting");
        return;
    }

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

    // ======= Test applyPattern() and toPattern()
    logln("SelectFormat API test: Testing applyPattern() and toPattern() ...");
    UnicodeString pattern = UnicodeString("masculine{masculineVerbValue} other{otherVerbValue}");
    status1 = U_ZERO_ERROR;
    selFmt1->applyPattern( pattern, status1);
    if (U_FAILURE(status1)) {
        errln("ERROR: SelectFormat API test failed in applyPattern() with pattern: "+ pattern);
    }else{
        UnicodeString checkPattern;
        selFmt1->toPattern( checkPattern);
        if( checkPattern != pattern ){
            errln("ERROR: SelectFormat API test failed in toPattern() with unexpected result with pattern: "+ pattern);
        }
    }

    // ======= Test different format() methods 
    logln("SelectFormat API test: Testing  format() with keyword method ...");
    status1 = U_ZERO_ERROR;
    UnicodeString result;
    FieldPosition ignore(FieldPosition::DONT_CARE);
    UnicodeString keyWord = UnicodeString("masculine");

    selFmt1->format( keyWord, result , ignore , status1);
    if (U_FAILURE(status1)) {
        errln("ERROR: SelectFormat API test failed in format() with keyWord: "+ keyWord);
    }else{
        UnicodeString expected=UnicodeString("masculineVerbValue");
        if( result != expected ){
            errln("ERROR: SelectFormat API test failed in format() with unexpected result with keyWord: "+ keyWord);
        }
    }
    
    logln("SelectFormat API test: Testing  format() with Formattable obj method ...");
    status1 = U_ZERO_ERROR;
    result.remove();
    UnicodeString result1;
    Formattable testArgs = Formattable("other");
    selFmt1->format( testArgs, result1 , ignore , status1);
    if (U_FAILURE(status1)) {
        errln("ERROR: SelectFormat API test failed in format() with Formattable");
    }else{
        UnicodeString expected=UnicodeString("otherVerbValue");
        if( result1 != expected ){
            errln("ERROR: SelectFormat API test failed in format() with unexpected result with Formattable");
        }
    }


    delete selFmt1;
}
#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
729e4ab9 A	1	/********************************************************************
	2	* COPYRIGHT:
	3	* Copyright (c) 1997-2010, International Business Machines Corporation and
	4	* others. All Rights Reserved.
	5	* Copyright (C) 2010 , Yahoo! Inc.
	6	********************************************************************/
	7
	8	#include "unicode/utypes.h"
	9
	10	#if !UCONFIG_NO_FORMATTING
	11
	12	#include "selfmts.h"
	13	#include "cmemory.h"
	14	#include "unicode/selfmt.h"
	15	#include "stdio.h"
	16
	17	#define SIMPLE_PATTERN_STRING "feminine {feminineVerbValue} other{otherVerbValue}"
	18
	19
	20	#define SELECT_PATTERN_DATA 4
	21	#define SELECT_SYNTAX_DATA 10
	22	#define EXP_FORMAT_RESULT_DATA 12
	23	#define NUM_OF_FORMAT_ARGS 3
	24
	25	#define VERBOSE_INT(x) {logln("%s:%d: int %s=%d\n", __FILE__, __LINE__, #x, (x));}
	26	#define VERBOSE_USTRING(text) {logln("%s:%d: UnicodeString %s(%d) = ", __FILE__, __LINE__, #text, text.length()); logln(UnicodeString(" \"")+text+UnicodeString("\";"));}
	27
	28
	29	void SelectFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	30	{
	31	if (exec) logln("TestSuite SelectFormat");
	32	switch (index) {
	33	TESTCASE(0, selectFormatAPITest);
	34	TESTCASE(1, selectFormatUnitTest);
	35	default: name = "";
	36	break;
	37	}
	38	}
	39
	40	/**
	41	* Unit tests of SelectFormat class.
	42	*/
	43	void SelectFormatTest::selectFormatUnitTest(/char par*/)
	44	{
	45	const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */
	46
	47	UnicodeString patternTestData[SELECT_PATTERN_DATA] = {
	48	UNICODE_STRING_SIMPLE("fem {femValue} other{even}"),
	49	UNICODE_STRING_SIMPLE("other{odd or even}"),
	50	UNICODE_STRING_SIMPLE("odd{The number {0, number, integer} is odd.}other{The number {0, number, integer} is even.}"),
	51	UNICODE_STRING_SIMPLE("odd{The number {1} is odd}other{The number {1} is even}"),
	52	};
	53
	54	UnicodeString formatArgs[NUM_OF_FORMAT_ARGS] = {
	55	UNICODE_STRING_SIMPLE("fem"),
	56	UNICODE_STRING_SIMPLE("other"),
	57	UNICODE_STRING_SIMPLE("odd")
	58	};
	59
	60	UnicodeString expFormatResult[][NUM_OF_FORMAT_ARGS] = {
	61	{
	62	UNICODE_STRING_SIMPLE("femValue"),
	63	UNICODE_STRING_SIMPLE("even"),
	64	UNICODE_STRING_SIMPLE("even")
65	},
66	{
67	UNICODE_STRING_SIMPLE("odd or even"),
68	UNICODE_STRING_SIMPLE("odd or even"),
69	UNICODE_STRING_SIMPLE("odd or even"),
70	},
71	{
72	UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
73	UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
74	UNICODE_STRING_SIMPLE("The number {0, number, integer} is odd."),
75	},
76	{
77	UNICODE_STRING_SIMPLE("The number {1} is even"),
78	UNICODE_STRING_SIMPLE("The number {1} is even"),
79	UNICODE_STRING_SIMPLE("The number {1} is odd"),
80	}
81	};
82
83	UnicodeString checkSyntaxData[SELECT_SYNTAX_DATA] = {
84	UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
85	UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
86	UNICODE_STRING_SIMPLE("odd{foo}"),
87	UNICODE_STRING_SIMPLE("1odd{foo} other{bar}"),
88	UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
89	UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
90	UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
91	UNICODE_STRING_SIMPLE("odd{foo1}other{foo2}}"),
92	UNICODE_STRING_SIMPLE("odd{foo1}other{{foo2}"),
93	UNICODE_STRING_SIMPLE("odd{fo{o1}other{foo2}}")
94	};
95
96	UErrorCode expErrorCodes[SELECT_SYNTAX_DATA]={
97	U_DUPLICATE_KEYWORD,
98	U_DUPLICATE_KEYWORD,
99	U_DEFAULT_KEYWORD_MISSING,
100	U_PATTERN_SYNTAX_ERROR,
101	U_PATTERN_SYNTAX_ERROR,
102	U_PATTERN_SYNTAX_ERROR,
103	U_PATTERN_SYNTAX_ERROR,
104	U_PATTERN_SYNTAX_ERROR,
105	U_PATTERN_SYNTAX_ERROR,
106	U_DEFAULT_KEYWORD_MISSING
107	};
108
109	UErrorCode status = U_ZERO_ERROR;
110	VERBOSE_USTRING(SIMPLE_PATTERN);
111	SelectFormat* selFmt = new SelectFormat( SIMPLE_PATTERN , status);
112	if (U_FAILURE(status)) {
113	dataerrln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
114	return;
115	}
116
117	// ======= Test SelectFormat pattern syntax.
118	logln("SelectFormat Unit Test : Testing SelectFormat pattern syntax.");
119	for (int32_t i=0; i<SELECT_SYNTAX_DATA; ++i) {
120	status = U_ZERO_ERROR;
121	VERBOSE_INT(i);
122	VERBOSE_USTRING(checkSyntaxData[i]);
123	selFmt->applyPattern(checkSyntaxData[i], status);
124	if( status!= expErrorCodes[i] ){
125	errln("\nERROR: Unexpected result - SelectFormat Unit Test failed to detect syntax error with pattern: "+checkSyntaxData[i]+" and expected status="+ u_errorName(expErrorCodes[i]) + " and resulted status="+u_errorName(status));
126	}
127	}
128
129	delete selFmt;
130	selFmt = NULL;
131
132	logln("SelectFormat Unit Test : Creating format object for Testing applying various patterns");
133	status = U_ZERO_ERROR;
134	selFmt = new SelectFormat( SIMPLE_PATTERN , status);
135	//SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status);
136	if (U_FAILURE(status)) {
137	errln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
138	return;
139	}
140
141	// ======= Test applying and formatting with various pattern
142	logln("SelectFormat Unit test: Testing applyPattern() and format() ...");
143	UnicodeString result;
144	FieldPosition ignore(FieldPosition::DONT_CARE);
145
146	for(int32_t i=0; i<SELECT_PATTERN_DATA; ++i) {
147	status = U_ZERO_ERROR;
148	selFmt->applyPattern(patternTestData[i], status);
149	if (U_FAILURE(status)) {
150	errln("ERROR: SelectFormat Unit Test failed to apply pattern- "+patternTestData[i] );
151	continue;
152	}
153
154	//Format with the keyword array
155	for(int32_t j=0; j<3; j++) {
156	result.remove();
157	selFmt->format( formatArgs[j], result , ignore , status);
158	if (U_FAILURE(status)) {
159	errln("ERROR: SelectFormat Unit test failed in format() with argument: "+ formatArgs[j] + " and error is " + u_errorName(status) );
160	}else{
161	if( result != expFormatResult[i][j] ){
162	errln("ERROR: SelectFormat Unit test failed in format() with unexpected result\n with argument: "+ formatArgs[j] + "\n result obtained: " + result + "\n and expected is: " + expFormatResult[i][j] );
163	}
164	}
165	}
166	}
167
168	//Test with an invalid keyword
169	logln("SelectFormat Unit test: Testing format() with keyword method and with invalid keywords...");
170	status = U_ZERO_ERROR;
171	result.remove();
172	UnicodeString keywords[] = {
173	"9Keyword-_", //Starts with a digit
174	"-Keyword-_", //Starts with a hyphen
175	"_Keyword-_", //Starts with a underscore
176	"\\u00E9Keyword-_", //Starts with non-ASCII character
177	"Key*word-_", //Contains a sepial character not allowed
178	"*Keyword-_" //Starts with a sepial character not allowed
179	};
180
181	delete selFmt;
182	selFmt = NULL;
183
184	selFmt = new SelectFormat( SIMPLE_PATTERN , status);
185	for (int32_t i = 0; i< 6; i++ ){
186	status = U_ZERO_ERROR;
187	selFmt->format( keywords[i], result , ignore , status);
188	if (!U_FAILURE(status)) {
189	errln("ERROR: SelectFormat Unit test failed in format() with keyWord and with an invalid keyword as : "+ keywords[i]);
190	}
191	}
192
193	delete selFmt;
194	}
195
196	/**
197	* Test various generic API methods of SelectFormat for Basic API usage.
198	* This is to make sure the API test coverage is 100% .
199	*/
200	void SelectFormatTest::selectFormatAPITest(/char par*/)
201	{
202	const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */
203	int numOfConstructors =3;
204	UErrorCode status[3];
205	SelectFormat* selFmt[3] = { NULL, NULL, NULL };
206
207	// ========= Test constructors
208	logln("SelectFormat API test: Testing SelectFormat constructors ...");
209	for (int32_t i=0; i< numOfConstructors; ++i) {
210	status[i] = U_ZERO_ERROR;
211	}
212
213	selFmt[0]= new SelectFormat(SIMPLE_PATTERN, status[0]);
214	if ( U_FAILURE(status[0]) ) {
215	errln("ERROR: SelectFormat API test constructor with pattern and status failed! with %s\n", u_errorName(status[0]));
216	return;
217	}
218
219	// =========== Test copy constructor
220	logln("SelectFormat API test: Testing copy constructor and == operator ...");
221	SelectFormat fmt = *selFmt[0];
222	SelectFormat* dupPFmt = new SelectFormat(fmt);
223	if ((selFmt[0]) != (dupPFmt)) {
224	errln("ERROR: SelectFormat API test Failed in copy constructor or == operator!");
225	}
226	delete dupPFmt;
227
228	// ======= Test clone && == operator.
229	logln("SelectFormat API test: Testing clone and == operator ...");
230	if ( U_SUCCESS(status[0]) ) {
231	selFmt[1] = (SelectFormat*)selFmt[0]->clone();
232	if (selFmt[1]!=NULL) {
233	if ( selFmt[1] != selFmt[0] ) {
234	errln("ERROR: SelectFormat API test clone test failed!");
235	}
236	} else {
237	errln("ERROR: SelectFormat API test clone test failed with NULL!");
238	return;
239	}
240	} else {
241	errln("ERROR: could not create [0]: %s\n", u_errorName(status[0]));
242	return;
243	}
244
245	// ======= Test assignment operator && == operator.
246	logln("SelectFormat API test: Testing assignment operator and == operator ...");
247	selFmt[2]= new SelectFormat(SIMPLE_PATTERN, status[2]);
248	if ( U_SUCCESS(status[2]) ) {
249	selFmt[1] = selFmt[2];
250	if (selFmt[1]!=NULL) {
251	if ( (selFmt[1] != selFmt[2]) ) {
252	errln("ERROR: SelectFormat API test assignment operator test failed!");
253	}
254	}
255	delete selFmt[1];
256	}
257	else {
258	errln("ERROR: SelectFormat constructor failed in assignment operator!");
259	}
260	delete selFmt[0];
261	delete selFmt[2];
262
263	// ======= Test getStaticClassID() and getStaticClassID()
264	logln("SelectFormat API test: Testing getStaticClassID() and getStaticClassID() ...");
265	UErrorCode status1 = U_ZERO_ERROR;
266	SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status1);
267	if( U_FAILURE(status1)) {
268	errln("ERROR: SelectFormat constructor failed in staticClassID test! Exitting");
269	return;
270	}
271
272	logln("Testing getStaticClassID()");
273	if(selFmt1->getDynamicClassID() !=SelectFormat::getStaticClassID()) {
274	errln("ERROR: SelectFormat API test getDynamicClassID() didn't return the expected value");
275	}
276
277	// ======= Test applyPattern() and toPattern()
278	logln("SelectFormat API test: Testing applyPattern() and toPattern() ...");
279	UnicodeString pattern = UnicodeString("masculine{masculineVerbValue} other{otherVerbValue}");
280	status1 = U_ZERO_ERROR;
281	selFmt1->applyPattern( pattern, status1);
282	if (U_FAILURE(status1)) {
283	errln("ERROR: SelectFormat API test failed in applyPattern() with pattern: "+ pattern);
284	}else{
285	UnicodeString checkPattern;
286	selFmt1->toPattern( checkPattern);
287	if( checkPattern != pattern ){
288	errln("ERROR: SelectFormat API test failed in toPattern() with unexpected result with pattern: "+ pattern);
289	}
290	}
291
292	// ======= Test different format() methods
293	logln("SelectFormat API test: Testing format() with keyword method ...");
294	status1 = U_ZERO_ERROR;
295	UnicodeString result;
296	FieldPosition ignore(FieldPosition::DONT_CARE);
297	UnicodeString keyWord = UnicodeString("masculine");
298
299	selFmt1->format( keyWord, result , ignore , status1);
300	if (U_FAILURE(status1)) {
301	errln("ERROR: SelectFormat API test failed in format() with keyWord: "+ keyWord);
302	}else{
303	UnicodeString expected=UnicodeString("masculineVerbValue");
304	if( result != expected ){
305	errln("ERROR: SelectFormat API test failed in format() with unexpected result with keyWord: "+ keyWord);
306	}
307	}
308
309	logln("SelectFormat API test: Testing format() with Formattable obj method ...");
310	status1 = U_ZERO_ERROR;
311	result.remove();
312	UnicodeString result1;
313	Formattable testArgs = Formattable("other");
314	selFmt1->format( testArgs, result1 , ignore , status1);
315	if (U_FAILURE(status1)) {
316	errln("ERROR: SelectFormat API test failed in format() with Formattable");
317	}else{
318	UnicodeString expected=UnicodeString("otherVerbValue");
319	if( result1 != expected ){
320	errln("ERROR: SelectFormat API test failed in format() with unexpected result with Formattable");
321	}
322	}
323
324
325	delete selFmt1;
326	}
327	#endif /* #if !UCONFIG_NO_FORMATTING */