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
30void 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
80void 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
117void 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
163void 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
363void 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