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