1
2/***********************************************************************
3 * COPYRIGHT:
4 * Copyright (c) 1997-2012, 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
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
22#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
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
31void test_ParsePosition( void )
32{
33    ParsePosition* pp1 = new ParsePosition();
34    if (pp1 && (pp1->getIndex() == 0)) {
35        it_logln("PP constructor() tested.");
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) {
46            it_logln("PP getIndex and constructor(int32_t) tested.");
47        }else{
48            it_errln("*** PP getIndex or constructor(int32_t) result");
49        }
50        pp2.setIndex( 3 );
51        if (pp2.getIndex() == 3) {
52            it_logln("PP setIndex tested.");
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)) {
63        it_logln("PP copy contructor, operator== and operator != tested.");
64    }else{
65        it_errln("*** PP operator== or operator != result");
66    }
67
68    ParsePosition pp5;
69    pp5 = pp4;
70    if ((pp4 == pp5) && (!(pp4 != pp5))) {
71        it_logln("PP operator= tested.");
72    }else{
73        it_errln("*** PP operator= operator== or operator != result");
74    }
75
76
77}
78
79#include "unicode/decimfmt.h"
80
81void 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);
91    if (U_FAILURE(status)) {
92        it_dataerrln("NumberFormat::createInstance() error");
93        return;
94    }
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';
110        it_logln(UnicodeString("FP ") + UnicodeString(temp) + res);
111    }
112    delete fmt;
113
114    it_logln("");
115
116}
117
118void test_FieldPosition( void )
119{
120
121    FieldPosition fp( 7 );
122
123    if (fp.getField() == 7) {
124        it_logln("FP constructor(int32_t) and getField tested.");
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) {
145        it_logln("FP setField and getField tested.");
146    }else{
147        it_errln("*** FP setField or getField");
148    }
149    if (!err2) {
150        it_logln("FP setBeginIndex and getBeginIndex tested.");
151    }else{
152        it_errln("*** FP setBeginIndex or getBeginIndex");
153    }
154    if (!err3) {
155        it_logln("FP setEndIndex and getEndIndex tested.");
156    }else{
157        it_errln("*** FP setEndIndex or getEndIndex");
158    }
159
160    it_logln("");
161
162}
163
164void test_Formattable( void )
165{
166    UErrorCode status = U_ZERO_ERROR;
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)) {
176        it_logln("FT setLong, operator== and operator!= tested.");
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        }
184    }else{
185        it_errln("*** Formattable setLong or operator== or !=");
186    }
187    fta = ftb;
188    if ((fta == ftb) || !(fta != ftb)) {
189        it_logln("FT operator= tested.");
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)) {
196        it_logln("FT set- and getDouble tested.");
197    }else{
198        it_errln("*** FT set- or getDouble");
199    }
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    }
205    fta.setDate( 4.0 );
206    if ((fta.getType() == Formattable::kDate) && (fta.getDate() == 4.0)) {
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        }
215    }else{
216        it_errln("*** FT set- or getDate");
217    }
218
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
225    fta.setString("abc");
226    const Formattable ftc(fta);
227    UnicodeString res;
228
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    }
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    };
258    const int32_t ft_cnt = LENGTHOF(ftarray);
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) ) {
266        it_logln("FT constr. for date, double, long, ustring, ustring* and array tested");
267    }else{
268        it_errln("*** FT constr. for date, double, long, ustring, ustring* or array");
269    }
270
271    int32_t i, res_cnt;
272    const Formattable* res_array = ft_arr.getArray( res_cnt );
273    if (res_cnt == ft_cnt) {
274        UBool same  = TRUE;
275        for (i = 0; i < res_cnt; i++ ) {
276            if (res_array[i] != ftarray[i]) {
277                same = FALSE;
278            }
279        }
280        if (same) {
281            it_logln("FT getArray tested");
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            }
288        }else{
289            it_errln("*** FT getArray comparison");
290        }
291    }else{
292        it_errln(UnicodeString("*** FT getArray count res_cnt=") + res_cnt + UnicodeString("ft_cnt=") + ft_cnt);
293    }
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    }
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]) {
311            it_errln(UnicodeString("Formattable.clone() failed for item ") + i);
312        }
313        delete pf;
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)) {
324        it_logln("FT setArray tested");
325    }else{
326        it_errln("*** FT setArray");
327    }
328
329    Formattable* ft_dynarr = new Formattable[ftarr2_cnt];
330    for (i = 0; i < ftarr2_cnt; i++ ) {
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)) {
335        it_logln("FT operator= and array operations tested");
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)) {
343        it_logln("FT adoptArray tested");
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")) {
355        it_logln("FT adoptString tested");
356    }else{
357        it_errln("*** FT adoptString or getString");
358    }
359    fta.setLong(0);   // calls 'dispose' and deletes adopted string !
360
361    it_logln();
362}
363
364void 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 */
388